Ruby: prism_compile.c Source File

Ruby 3.4.7p58 (2025-10-08 revision 7a5688e2a27668e48f8d6ff4af5b2208b98a2f5e)

prism_compile.c
1#include "prism.h"
2#include "version.h"
3
9 typedef struct {
11 int32_t line;
12
14 uint32_t node_id;
15} pm_node_location_t;
16
17/******************************************************************************/
18/* These macros operate on pm_node_location_t structs as opposed to NODE*s. */
19/******************************************************************************/
20
21#define PUSH_ADJUST(seq, location, label) \
22 ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), (int) (location).line))
23
24#define PUSH_ADJUST_RESTORE(seq, label) \
25 ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), -1))
26
27#define PUSH_INSN(seq, location, insn) \
28 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 0))
29
30#define PUSH_INSN1(seq, location, insn, op1) \
31 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 1, (VALUE)(op1)))
32
33#define PUSH_INSN2(seq, location, insn, op1, op2) \
34 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 2, (VALUE)(op1), (VALUE)(op2)))
35
36#define PUSH_INSN3(seq, location, insn, op1, op2, op3) \
37 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 3, (VALUE)(op1), (VALUE)(op2), (VALUE)(op3)))
38
39#define PUSH_INSNL(seq, location, insn, label) \
40 (PUSH_INSN1(seq, location, insn, label), LABEL_REF(label))
41
42#define PUSH_LABEL(seq, label) \
43 ADD_ELEM((seq), (LINK_ELEMENT *) (label))
44
45#define PUSH_SEND_R(seq, location, id, argc, block, flag, keywords) \
46 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_send(iseq, (int) (location).line, (int) (location).node_id, (id), (VALUE)(argc), (block), (VALUE)(flag), (keywords)))
47
48#define PUSH_SEND(seq, location, id, argc) \
49 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)INT2FIX(0), NULL)
50
51#define PUSH_SEND_WITH_FLAG(seq, location, id, argc, flag) \
52 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)(flag), NULL)
53
54#define PUSH_SEND_WITH_BLOCK(seq, location, id, argc, block) \
55 PUSH_SEND_R((seq), location, (id), (argc), (block), (VALUE)INT2FIX(0), NULL)
56
57#define PUSH_CALL(seq, location, id, argc) \
58 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)INT2FIX(VM_CALL_FCALL), NULL)
59
60#define PUSH_CALL_WITH_BLOCK(seq, location, id, argc, block) \
61 PUSH_SEND_R((seq), location, (id), (argc), (block), (VALUE)INT2FIX(VM_CALL_FCALL), NULL)
62
63#define PUSH_TRACE(seq, event) \
64 ADD_ELEM((seq), (LINK_ELEMENT *) new_trace_body(iseq, (event), 0))
65
66#define PUSH_CATCH_ENTRY(type, ls, le, iseqv, lc) \
67 ADD_CATCH_ENTRY((type), (ls), (le), (iseqv), (lc))
68
69#define PUSH_SEQ(seq1, seq2) \
70 APPEND_LIST((seq1), (seq2))
71
72#define PUSH_SYNTHETIC_PUTNIL(seq, iseq) \
73 do { \
74 int lineno = ISEQ_COMPILE_DATA(iseq)->last_line; \
75 if (lineno == 0) lineno = FIX2INT(rb_iseq_first_lineno(iseq)); \
76 ADD_SYNTHETIC_INSN(seq, lineno, -1, putnil); \
77 } while (0)
78
79/******************************************************************************/
80/* These functions compile getlocal/setlocal instructions but operate on */
81/* prism locations instead of NODEs. */
82/******************************************************************************/
83
84static void
85pm_iseq_add_getlocal(rb_iseq_t *iseq, LINK_ANCHOR *const seq, int line, int node_id, int idx, int level)
86{
87 if (iseq_local_block_param_p(iseq, idx, level)) {
88 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(getblockparam), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
89 }
90 else {
91 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(getlocal), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
92 }
93 if (level > 0) access_outer_variables(iseq, level, iseq_lvar_id(iseq, idx, level), Qfalse);
94}
95
96static void
97pm_iseq_add_setlocal(rb_iseq_t *iseq, LINK_ANCHOR *const seq, int line, int node_id, int idx, int level)
98{
99 if (iseq_local_block_param_p(iseq, idx, level)) {
100 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(setblockparam), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
101 }
102 else {
103 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(setlocal), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
104 }
105 if (level > 0) access_outer_variables(iseq, level, iseq_lvar_id(iseq, idx, level), Qtrue);
106}
107
108#define PUSH_GETLOCAL(seq, location, idx, level) \
109 pm_iseq_add_getlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
110
111#define PUSH_SETLOCAL(seq, location, idx, level) \
112 pm_iseq_add_setlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
113
114/******************************************************************************/
115/* These are helper macros for the compiler. */
116/******************************************************************************/
117
118#define OLD_ISEQ NEW_ISEQ
119#undef NEW_ISEQ
120
121#define NEW_ISEQ(node, name, type, line_no) \
122 pm_new_child_iseq(iseq, (node), rb_fstring(name), 0, (type), (line_no))
123
124#define OLD_CHILD_ISEQ NEW_CHILD_ISEQ
125#undef NEW_CHILD_ISEQ
126
127#define NEW_CHILD_ISEQ(node, name, type, line_no) \
128 pm_new_child_iseq(iseq, (node), rb_fstring(name), iseq, (type), (line_no))
129
130#define PM_COMPILE(node) \
131 pm_compile_node(iseq, (node), ret, popped, scope_node)
132
133#define PM_COMPILE_INTO_ANCHOR(_ret, node) \
134 pm_compile_node(iseq, (node), _ret, popped, scope_node)
135
136#define PM_COMPILE_POPPED(node) \
137 pm_compile_node(iseq, (node), ret, true, scope_node)
138
139#define PM_COMPILE_NOT_POPPED(node) \
140 pm_compile_node(iseq, (node), ret, false, scope_node)
141
142#define PM_NODE_START_LOCATION(parser, node) \
143 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, ((const pm_node_t *) (node))->location.start, (parser)->start_line), .node_id = ((const pm_node_t *) (node))->node_id })
144
145#define PM_NODE_END_LOCATION(parser, node) \
146 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, ((const pm_node_t *) (node))->location.end, (parser)->start_line), .node_id = ((const pm_node_t *) (node))->node_id })
147
148#define PM_LOCATION_START_LOCATION(parser, location, id) \
149 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, (location)->start, (parser)->start_line), .node_id = id })
150
151#define PM_NODE_START_LINE_COLUMN(parser, node) \
152 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.start, (parser)->start_line)
153
154#define PM_NODE_END_LINE_COLUMN(parser, node) \
155 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.end, (parser)->start_line)
156
157#define PM_LOCATION_START_LINE_COLUMN(parser, location) \
158 pm_newline_list_line_column(&(parser)->newline_list, (location)->start, (parser)->start_line)
159
160static int
161pm_node_line_number(const pm_parser_t *parser, const pm_node_t *node)
162{
163 return (int) pm_newline_list_line(&parser->newline_list, node->location.start, parser->start_line);
164}
165
166static int
167pm_location_line_number(const pm_parser_t *parser, const pm_location_t *location) {
168 return (int) pm_newline_list_line(&parser->newline_list, location->start, parser->start_line);
169}
170
174static VALUE
175parse_integer_value(const pm_integer_t *integer)
176{
177 VALUE result;
178
179 if (integer->values == NULL) {
180 result = UINT2NUM(integer->value);
181 }
182 else {
183 VALUE string = rb_str_new(NULL, integer->length * 8);
184 unsigned char *bytes = (unsigned char *) RSTRING_PTR(string);
185
186 size_t offset = integer->length * 8;
187 for (size_t value_index = 0; value_index < integer->length; value_index++) {
188 uint32_t value = integer->values[value_index];
189
190 for (int index = 0; index < 8; index++) {
191 int byte = (value >> (4 * index)) & 0xf;
192 bytes[--offset] = byte < 10 ? byte + '0' : byte - 10 + 'a';
193 }
194 }
195
196 result = rb_funcall(string, rb_intern("to_i"), 1, UINT2NUM(16));
197 }
198
199 if (integer->negative) {
200 result = rb_funcall(result, rb_intern("-@"), 0);
201 }
202
203 return result;
204}
205
209static inline VALUE
210parse_integer(const pm_integer_node_t *node)
211{
212 return parse_integer_value(&node->value);
213}
214
218static VALUE
219parse_float(const pm_float_node_t *node)
220{
221 return DBL2NUM(node->value);
222}
223
230static VALUE
231parse_rational(const pm_rational_node_t *node)
232{
233 VALUE numerator = parse_integer_value(&node->numerator);
234 VALUE denominator = parse_integer_value(&node->denominator);
235 return rb_rational_new(numerator, denominator);
236}
237
244static VALUE
245parse_imaginary(const pm_imaginary_node_t *node)
246{
247 VALUE imaginary_part;
248 switch (PM_NODE_TYPE(node->numeric)) {
249 case PM_FLOAT_NODE: {
250 imaginary_part = parse_float((const pm_float_node_t *) node->numeric);
251 break;
252 }
253 case PM_INTEGER_NODE: {
254 imaginary_part = parse_integer((const pm_integer_node_t *) node->numeric);
255 break;
256 }
257 case PM_RATIONAL_NODE: {
258 imaginary_part = parse_rational((const pm_rational_node_t *) node->numeric);
259 break;
260 }
261 default:
262 rb_bug("Unexpected numeric type on imaginary number %s\n", pm_node_type_to_str(PM_NODE_TYPE(node->numeric)));
263 }
264
265 return rb_complex_raw(INT2FIX(0), imaginary_part);
266}
267
268static inline VALUE
269parse_string(const pm_scope_node_t *scope_node, const pm_string_t *string)
270{
271 return rb_enc_str_new((const char *) pm_string_source(string), pm_string_length(string), scope_node->encoding);
272}
273
279static inline VALUE
280parse_string_encoded(const pm_node_t *node, const pm_string_t *string, rb_encoding *default_encoding)
281{
282 rb_encoding *encoding;
283
284 if (node->flags & PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING) {
285 encoding = rb_ascii8bit_encoding();
286 }
287 else if (node->flags & PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING) {
288 encoding = rb_utf8_encoding();
289 }
290 else {
291 encoding = default_encoding;
292 }
293
294 return rb_enc_str_new((const char *) pm_string_source(string), pm_string_length(string), encoding);
295}
296
297static inline VALUE
298parse_static_literal_string(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_string_t *string)
299{
300 rb_encoding *encoding;
301
302 if (node->flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
303 encoding = rb_ascii8bit_encoding();
304 }
305 else if (node->flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
306 encoding = rb_utf8_encoding();
307 }
308 else {
309 encoding = scope_node->encoding;
310 }
311
312 VALUE value = rb_enc_literal_str((const char *) pm_string_source(string), pm_string_length(string), encoding);
313 rb_enc_str_coderange(value);
314
315 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
316 int line_number = pm_node_line_number(scope_node->parser, node);
317 value = rb_str_with_debug_created_info(value, rb_iseq_path(iseq), line_number);
318 }
319
320 return value;
321}
322
323static inline ID
324parse_string_symbol(const pm_scope_node_t *scope_node, const pm_symbol_node_t *symbol)
325{
326 rb_encoding *encoding;
327 if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING) {
328 encoding = rb_utf8_encoding();
329 }
330 else if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING) {
331 encoding = rb_ascii8bit_encoding();
332 }
333 else if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING) {
334 encoding = rb_usascii_encoding();
335 }
336 else {
337 encoding = scope_node->encoding;
338 }
339
340 return rb_intern3((const char *) pm_string_source(&symbol->unescaped), pm_string_length(&symbol->unescaped), encoding);
341}
342
343static int
344pm_optimizable_range_item_p(const pm_node_t *node)
345{
346 return (!node || PM_NODE_TYPE_P(node, PM_INTEGER_NODE) || PM_NODE_TYPE_P(node, PM_NIL_NODE));
347}
348
350static VALUE
351parse_regexp_error(rb_iseq_t *iseq, int32_t line_number, const char *fmt, ...)
352{
353 va_list args;
354 va_start(args, fmt);
355 VALUE error = rb_syntax_error_append(Qnil, rb_iseq_path(iseq), line_number, -1, NULL, "%" PRIsVALUE, args);
356 va_end(args);
357 rb_exc_raise(error);
358}
359
360static VALUE
361parse_regexp_string_part(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_string_t *unescaped, rb_encoding *implicit_regexp_encoding, rb_encoding *explicit_regexp_encoding)
362{
363 // If we were passed an explicit regexp encoding, then we need to double
364 // check that it's okay here for this fragment of the string.
365 rb_encoding *encoding;
366
367 if (explicit_regexp_encoding != NULL) {
368 encoding = explicit_regexp_encoding;
369 }
370 else if (node->flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
371 encoding = rb_ascii8bit_encoding();
372 }
373 else if (node->flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
374 encoding = rb_utf8_encoding();
375 }
376 else {
377 encoding = implicit_regexp_encoding;
378 }
379
380 VALUE string = rb_enc_str_new((const char *) pm_string_source(unescaped), pm_string_length(unescaped), encoding);
381 VALUE error = rb_reg_check_preprocess(string);
382
383 if (error != Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, node), "%" PRIsVALUE, rb_obj_as_string(error));
384 return string;
385}
386
387static VALUE
388pm_static_literal_concat(rb_iseq_t *iseq, const pm_node_list_t *nodes, const pm_scope_node_t *scope_node, rb_encoding *implicit_regexp_encoding, rb_encoding *explicit_regexp_encoding, bool top)
389{
390 VALUE current = Qnil;
391
392 for (size_t index = 0; index < nodes->size; index++) {
393 const pm_node_t *part = nodes->nodes[index];
394 VALUE string;
395
396 switch (PM_NODE_TYPE(part)) {
397 case PM_STRING_NODE:
398 if (implicit_regexp_encoding != NULL) {
399 if (top) {
400 string = parse_regexp_string_part(iseq, scope_node, part, &((const pm_string_node_t *) part)->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
401 }
402 else {
403 string = parse_string_encoded(part, &((const pm_string_node_t *) part)->unescaped, scope_node->encoding);
404 VALUE error = rb_reg_check_preprocess(string);
405 if (error != Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, part), "%" PRIsVALUE, rb_obj_as_string(error));
406 }
407 }
408 else {
409 string = parse_string_encoded(part, &((const pm_string_node_t *) part)->unescaped, scope_node->encoding);
410 }
411 break;
412 case PM_INTERPOLATED_STRING_NODE:
413 string = pm_static_literal_concat(iseq, &((const pm_interpolated_string_node_t *) part)->parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
414 break;
415 case PM_EMBEDDED_STATEMENTS_NODE: {
416 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) part;
417 string = pm_static_literal_concat(iseq, &cast->statements->body, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
418 break;
419 }
420 default:
421 RUBY_ASSERT(false && "unexpected node type in pm_static_literal_concat");
422 return Qnil;
423 }
424
425 if (current != Qnil) {
426 current = rb_str_concat(current, string);
427 }
428 else {
429 current = string;
430 }
431 }
432
433 return top ? rb_fstring(current) : current;
434}
435
436#define RE_OPTION_ENCODING_SHIFT 8
437#define RE_OPTION_ENCODING(encoding) (((encoding) & 0xFF) << RE_OPTION_ENCODING_SHIFT)
438#define ARG_ENCODING_NONE 32
439#define ARG_ENCODING_FIXED 16
440#define ENC_ASCII8BIT 1
441#define ENC_EUC_JP 2
442#define ENC_Windows_31J 3
443#define ENC_UTF8 4
444
449static int
450parse_regexp_flags(const pm_node_t *node)
451{
452 int flags = 0;
453
454 // Check "no encoding" first so that flags don't get clobbered
455 // We're calling `rb_char_to_option_kcode` in this case so that
456 // we don't need to have access to `ARG_ENCODING_NONE`
457 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
458 flags |= ARG_ENCODING_NONE;
459 }
460
461 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
462 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_EUC_JP));
463 }
464
465 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
466 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_Windows_31J));
467 }
468
469 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
470 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_UTF8));
471 }
472
473 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
474 flags |= ONIG_OPTION_IGNORECASE;
475 }
476
477 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
478 flags |= ONIG_OPTION_MULTILINE;
479 }
480
481 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
482 flags |= ONIG_OPTION_EXTEND;
483 }
484
485 return flags;
486}
487
488#undef RE_OPTION_ENCODING_SHIFT
489#undef RE_OPTION_ENCODING
490#undef ARG_ENCODING_FIXED
491#undef ARG_ENCODING_NONE
492#undef ENC_ASCII8BIT
493#undef ENC_EUC_JP
494#undef ENC_Windows_31J
495#undef ENC_UTF8
496
497static rb_encoding *
498parse_regexp_encoding(const pm_scope_node_t *scope_node, const pm_node_t *node)
499{
500 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) || PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
501 return rb_ascii8bit_encoding();
502 }
503 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
504 return rb_utf8_encoding();
505 }
506 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
507 return rb_enc_get_from_index(ENCINDEX_EUC_JP);
508 }
509 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
510 return rb_enc_get_from_index(ENCINDEX_Windows_31J);
511 }
512 else {
513 return NULL;
514 }
515}
516
517static VALUE
518parse_regexp(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, VALUE string)
519{
520 VALUE errinfo = rb_errinfo();
521
522 int32_t line_number = pm_node_line_number(scope_node->parser, node);
523 VALUE regexp = rb_reg_compile(string, parse_regexp_flags(node), (const char *) pm_string_source(&scope_node->parser->filepath), line_number);
524
525 if (NIL_P(regexp)) {
526 VALUE message = rb_attr_get(rb_errinfo(), idMesg);
527 rb_set_errinfo(errinfo);
528
529 parse_regexp_error(iseq, line_number, "%" PRIsVALUE, message);
530 return Qnil;
531 }
532
533 rb_obj_freeze(regexp);
534 return regexp;
535}
536
537static inline VALUE
538parse_regexp_literal(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_string_t *unescaped)
539{
540 rb_encoding *regexp_encoding = parse_regexp_encoding(scope_node, node);
541 if (regexp_encoding == NULL) regexp_encoding = scope_node->encoding;
542
543 VALUE string = rb_enc_str_new((const char *) pm_string_source(unescaped), pm_string_length(unescaped), regexp_encoding);
544 return parse_regexp(iseq, scope_node, node, string);
545}
546
547static inline VALUE
548parse_regexp_concat(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_node_list_t *parts)
549{
550 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
551 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
552
553 VALUE string = pm_static_literal_concat(iseq, parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
554 return parse_regexp(iseq, scope_node, node, string);
555}
556
557static void pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node);
558
559static int
560pm_interpolated_node_compile(rb_iseq_t *iseq, const pm_node_list_t *parts, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node, rb_encoding *implicit_regexp_encoding, rb_encoding *explicit_regexp_encoding)
561{
562 int stack_size = 0;
563 size_t parts_size = parts->size;
564 bool interpolated = false;
565
566 if (parts_size > 0) {
567 VALUE current_string = Qnil;
568 pm_node_location_t current_location = *node_location;
569
570 for (size_t index = 0; index < parts_size; index++) {
571 const pm_node_t *part = parts->nodes[index];
572
573 if (PM_NODE_TYPE_P(part, PM_STRING_NODE)) {
574 const pm_string_node_t *string_node = (const pm_string_node_t *) part;
575 VALUE string_value;
576
577 if (implicit_regexp_encoding == NULL) {
578 string_value = parse_string_encoded(part, &string_node->unescaped, scope_node->encoding);
579 }
580 else {
581 string_value = parse_regexp_string_part(iseq, scope_node, (const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
582 }
583
584 if (RTEST(current_string)) {
585 current_string = rb_str_concat(current_string, string_value);
586 }
587 else {
588 current_string = string_value;
589 if (index != 0) current_location = PM_NODE_END_LOCATION(scope_node->parser, part);
590 }
591 }
592 else {
593 interpolated = true;
594
595 if (
596 PM_NODE_TYPE_P(part, PM_EMBEDDED_STATEMENTS_NODE) &&
597 ((const pm_embedded_statements_node_t *) part)->statements != NULL &&
598 ((const pm_embedded_statements_node_t *) part)->statements->body.size == 1 &&
599 PM_NODE_TYPE_P(((const pm_embedded_statements_node_t *) part)->statements->body.nodes[0], PM_STRING_NODE)
600 ) {
601 const pm_string_node_t *string_node = (const pm_string_node_t *) ((const pm_embedded_statements_node_t *) part)->statements->body.nodes[0];
602 VALUE string_value;
603
604 if (implicit_regexp_encoding == NULL) {
605 string_value = parse_string_encoded(part, &string_node->unescaped, scope_node->encoding);
606 }
607 else {
608 string_value = parse_regexp_string_part(iseq, scope_node, (const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
609 }
610
611 if (RTEST(current_string)) {
612 current_string = rb_str_concat(current_string, string_value);
613 }
614 else {
615 current_string = string_value;
616 current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
617 }
618 }
619 else {
620 if (!RTEST(current_string)) {
621 rb_encoding *encoding;
622
623 if (implicit_regexp_encoding != NULL) {
624 if (explicit_regexp_encoding != NULL) {
625 encoding = explicit_regexp_encoding;
626 }
627 else if (scope_node->parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
628 encoding = rb_ascii8bit_encoding();
629 }
630 else {
631 encoding = implicit_regexp_encoding;
632 }
633 }
634 else {
635 encoding = scope_node->encoding;
636 }
637
638 if (parts_size == 1) {
639 current_string = rb_enc_str_new(NULL, 0, encoding);
640 }
641 }
642
643 if (RTEST(current_string)) {
644 VALUE operand = rb_fstring(current_string);
645 PUSH_INSN1(ret, current_location, putobject, operand);
646 stack_size++;
647 }
648
649 PM_COMPILE_NOT_POPPED(part);
650
651 const pm_node_location_t current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
652 PUSH_INSN(ret, current_location, dup);
653
654 {
655 const struct rb_callinfo *callinfo = new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE, NULL, FALSE);
656 PUSH_INSN1(ret, current_location, objtostring, callinfo);
657 }
658
659 PUSH_INSN(ret, current_location, anytostring);
660
661 current_string = Qnil;
662 stack_size++;
663 }
664 }
665 }
666
667 if (RTEST(current_string)) {
668 current_string = rb_fstring(current_string);
669
670 if (stack_size == 0 && interpolated) {
671 PUSH_INSN1(ret, current_location, putstring, current_string);
672 }
673 else {
674 PUSH_INSN1(ret, current_location, putobject, current_string);
675 }
676
677 current_string = Qnil;
678 stack_size++;
679 }
680 }
681 else {
682 PUSH_INSN(ret, *node_location, putnil);
683 }
684
685 return stack_size;
686}
687
688static void
689pm_compile_regexp_dynamic(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_list_t *parts, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
690{
691 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
692 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
693
694 int length = pm_interpolated_node_compile(iseq, parts, node_location, ret, popped, scope_node, implicit_regexp_encoding, explicit_regexp_encoding);
695 PUSH_INSN2(ret, *node_location, toregexp, INT2FIX(parse_regexp_flags(node) & 0xFF), INT2FIX(length));
696}
697
698static VALUE
699pm_source_file_value(const pm_source_file_node_t *node, const pm_scope_node_t *scope_node)
700{
701 const pm_string_t *filepath = &node->filepath;
702 size_t length = pm_string_length(filepath);
703
704 if (length > 0) {
705 rb_encoding *filepath_encoding = scope_node->filepath_encoding != NULL ? scope_node->filepath_encoding : rb_utf8_encoding();
706 return rb_enc_interned_str((const char *) pm_string_source(filepath), length, filepath_encoding);
707 }
708 else {
709 return rb_fstring_lit("<compiled>");
710 }
711}
712
717static VALUE
718pm_static_literal_string(rb_iseq_t *iseq, VALUE string, int line_number)
719{
720 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
721 return rb_str_with_debug_created_info(string, rb_iseq_path(iseq), line_number);
722 }
723 else {
724 return rb_fstring(string);
725 }
726}
727
733static VALUE
734pm_static_literal_value(rb_iseq_t *iseq, const pm_node_t *node, const pm_scope_node_t *scope_node)
735{
736 // Every node that comes into this function should already be marked as
737 // static literal. If it's not, then we have a bug somewhere.
738 RUBY_ASSERT(PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL));
739
740 switch (PM_NODE_TYPE(node)) {
741 case PM_ARRAY_NODE: {
742 const pm_array_node_t *cast = (const pm_array_node_t *) node;
743 const pm_node_list_t *elements = &cast->elements;
744
745 VALUE value = rb_ary_hidden_new(elements->size);
746 for (size_t index = 0; index < elements->size; index++) {
747 rb_ary_push(value, pm_static_literal_value(iseq, elements->nodes[index], scope_node));
748 }
749
750 OBJ_FREEZE(value);
751 return value;
752 }
753 case PM_FALSE_NODE:
754 return Qfalse;
755 case PM_FLOAT_NODE:
756 return parse_float((const pm_float_node_t *) node);
757 case PM_HASH_NODE: {
758 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
759 const pm_node_list_t *elements = &cast->elements;
760
761 VALUE array = rb_ary_hidden_new(elements->size * 2);
762 for (size_t index = 0; index < elements->size; index++) {
763 RUBY_ASSERT(PM_NODE_TYPE_P(elements->nodes[index], PM_ASSOC_NODE));
764 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) elements->nodes[index];
765 VALUE pair[2] = { pm_static_literal_value(iseq, cast->key, scope_node), pm_static_literal_value(iseq, cast->value, scope_node) };
766 rb_ary_cat(array, pair, 2);
767 }
768
769 VALUE value = rb_hash_new_with_size(elements->size);
770 rb_hash_bulk_insert(RARRAY_LEN(array), RARRAY_CONST_PTR(array), value);
771
772 value = rb_obj_hide(value);
773 OBJ_FREEZE(value);
774 return value;
775 }
776 case PM_IMAGINARY_NODE:
777 return parse_imaginary((const pm_imaginary_node_t *) node);
778 case PM_INTEGER_NODE:
779 return parse_integer((const pm_integer_node_t *) node);
780 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
781 const pm_interpolated_match_last_line_node_t *cast = (const pm_interpolated_match_last_line_node_t *) node;
782 return parse_regexp_concat(iseq, scope_node, (const pm_node_t *) cast, &cast->parts);
783 }
784 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
785 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
786 return parse_regexp_concat(iseq, scope_node, (const pm_node_t *) cast, &cast->parts);
787 }
788 case PM_INTERPOLATED_STRING_NODE: {
789 VALUE string = pm_static_literal_concat(iseq, &((const pm_interpolated_string_node_t *) node)->parts, scope_node, NULL, NULL, false);
790 int line_number = pm_node_line_number(scope_node->parser, node);
791 return pm_static_literal_string(iseq, string, line_number);
792 }
793 case PM_INTERPOLATED_SYMBOL_NODE: {
794 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
795 VALUE string = pm_static_literal_concat(iseq, &cast->parts, scope_node, NULL, NULL, true);
796
797 return ID2SYM(rb_intern_str(string));
798 }
799 case PM_MATCH_LAST_LINE_NODE: {
800 const pm_match_last_line_node_t *cast = (const pm_match_last_line_node_t *) node;
801 return parse_regexp_literal(iseq, scope_node, (const pm_node_t *) cast, &cast->unescaped);
802 }
803 case PM_NIL_NODE:
804 return Qnil;
805 case PM_RATIONAL_NODE:
806 return parse_rational((const pm_rational_node_t *) node);
807 case PM_REGULAR_EXPRESSION_NODE: {
808 const pm_regular_expression_node_t *cast = (const pm_regular_expression_node_t *) node;
809 return parse_regexp_literal(iseq, scope_node, (const pm_node_t *) cast, &cast->unescaped);
810 }
811 case PM_SOURCE_ENCODING_NODE:
812 return rb_enc_from_encoding(scope_node->encoding);
813 case PM_SOURCE_FILE_NODE: {
814 const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
815 return pm_source_file_value(cast, scope_node);
816 }
817 case PM_SOURCE_LINE_NODE:
818 return INT2FIX(pm_node_line_number(scope_node->parser, node));
819 case PM_STRING_NODE: {
820 const pm_string_node_t *cast = (const pm_string_node_t *) node;
821 return parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
822 }
823 case PM_SYMBOL_NODE:
824 return ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) node));
825 case PM_TRUE_NODE:
826 return Qtrue;
827 default:
828 rb_bug("Don't have a literal value for node type %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
829 return Qfalse;
830 }
831}
832
836static rb_code_location_t
837pm_code_location(const pm_scope_node_t *scope_node, const pm_node_t *node)
838{
839 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, node);
840 const pm_line_column_t end_location = PM_NODE_END_LINE_COLUMN(scope_node->parser, node);
841
842 return (rb_code_location_t) {
843 .beg_pos = { .lineno = start_location.line, .column = start_location.column },
844 .end_pos = { .lineno = end_location.line, .column = end_location.column }
845 };
846}
847
853#define PM_BRANCH_COVERAGE_P(iseq) (ISEQ_COVERAGE(iseq) && ISEQ_BRANCH_COVERAGE(iseq))
854
855static void
856pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond,
857 LABEL *then_label, LABEL *else_label, bool popped, pm_scope_node_t *scope_node);
858
859static void
860pm_compile_logical(rb_iseq_t *iseq, LINK_ANCHOR *const ret, pm_node_t *cond, LABEL *then_label, LABEL *else_label, bool popped, pm_scope_node_t *scope_node)
861{
862 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, cond);
863
864 DECL_ANCHOR(seq);
865
866 LABEL *label = NEW_LABEL(location.line);
867 if (!then_label) then_label = label;
868 else if (!else_label) else_label = label;
869
870 pm_compile_branch_condition(iseq, seq, cond, then_label, else_label, popped, scope_node);
871
872 if (LIST_INSN_SIZE_ONE(seq)) {
873 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(seq));
874 if (insn->insn_id == BIN(jump) && (LABEL *)(insn->operands[0]) == label) return;
875 }
876
877 if (!label->refcnt) {
878 if (popped) PUSH_INSN(ret, location, putnil);
879 }
880 else {
881 PUSH_LABEL(seq, label);
882 }
883
884 PUSH_SEQ(ret, seq);
885 return;
886}
887
888static void
889pm_compile_flip_flop_bound(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
890{
891 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
892
893 if (PM_NODE_TYPE_P(node, PM_INTEGER_NODE)) {
894 PM_COMPILE_NOT_POPPED(node);
895
896 VALUE operand = ID2SYM(rb_intern("$."));
897 PUSH_INSN1(ret, location, getglobal, operand);
898
899 PUSH_SEND(ret, location, idEq, INT2FIX(1));
900 if (popped) PUSH_INSN(ret, location, pop);
901 }
902 else {
903 PM_COMPILE(node);
904 }
905}
906
907static void
908pm_compile_flip_flop(const pm_flip_flop_node_t *flip_flop_node, LABEL *else_label, LABEL *then_label, rb_iseq_t *iseq, const int lineno, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
909{
910 const pm_node_location_t location = { .line = lineno, .node_id = -1 };
911 LABEL *lend = NEW_LABEL(location.line);
912
913 int again = !(flip_flop_node->base.flags & PM_RANGE_FLAGS_EXCLUDE_END);
914
915 rb_num_t count = ISEQ_FLIP_CNT_INCREMENT(ISEQ_BODY(iseq)->local_iseq) + VM_SVAR_FLIPFLOP_START;
916 VALUE key = INT2FIX(count);
917
918 PUSH_INSN2(ret, location, getspecial, key, INT2FIX(0));
919 PUSH_INSNL(ret, location, branchif, lend);
920
921 if (flip_flop_node->left) {
922 pm_compile_flip_flop_bound(iseq, flip_flop_node->left, ret, popped, scope_node);
923 }
924 else {
925 PUSH_INSN(ret, location, putnil);
926 }
927
928 PUSH_INSNL(ret, location, branchunless, else_label);
929 PUSH_INSN1(ret, location, putobject, Qtrue);
930 PUSH_INSN1(ret, location, setspecial, key);
931 if (!again) {
932 PUSH_INSNL(ret, location, jump, then_label);
933 }
934
935 PUSH_LABEL(ret, lend);
936 if (flip_flop_node->right) {
937 pm_compile_flip_flop_bound(iseq, flip_flop_node->right, ret, popped, scope_node);
938 }
939 else {
940 PUSH_INSN(ret, location, putnil);
941 }
942
943 PUSH_INSNL(ret, location, branchunless, then_label);
944 PUSH_INSN1(ret, location, putobject, Qfalse);
945 PUSH_INSN1(ret, location, setspecial, key);
946 PUSH_INSNL(ret, location, jump, then_label);
947}
948
949static void pm_compile_defined_expr(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node, bool in_condition);
950
951static void
952pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond, LABEL *then_label, LABEL *else_label, bool popped, pm_scope_node_t *scope_node)
953{
954 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, cond);
955
956again:
957 switch (PM_NODE_TYPE(cond)) {
958 case PM_AND_NODE: {
959 const pm_and_node_t *cast = (const pm_and_node_t *) cond;
960 pm_compile_logical(iseq, ret, cast->left, NULL, else_label, popped, scope_node);
961
962 cond = cast->right;
963 goto again;
964 }
965 case PM_OR_NODE: {
966 const pm_or_node_t *cast = (const pm_or_node_t *) cond;
967 pm_compile_logical(iseq, ret, cast->left, then_label, NULL, popped, scope_node);
968
969 cond = cast->right;
970 goto again;
971 }
972 case PM_FALSE_NODE:
973 case PM_NIL_NODE:
974 PUSH_INSNL(ret, location, jump, else_label);
975 return;
976 case PM_FLOAT_NODE:
977 case PM_IMAGINARY_NODE:
978 case PM_INTEGER_NODE:
979 case PM_LAMBDA_NODE:
980 case PM_RATIONAL_NODE:
981 case PM_REGULAR_EXPRESSION_NODE:
982 case PM_STRING_NODE:
983 case PM_SYMBOL_NODE:
984 case PM_TRUE_NODE:
985 PUSH_INSNL(ret, location, jump, then_label);
986 return;
987 case PM_FLIP_FLOP_NODE:
988 pm_compile_flip_flop((const pm_flip_flop_node_t *) cond, else_label, then_label, iseq, location.line, ret, popped, scope_node);
989 return;
990 case PM_DEFINED_NODE: {
991 const pm_defined_node_t *cast = (const pm_defined_node_t *) cond;
992 pm_compile_defined_expr(iseq, cast->value, &location, ret, popped, scope_node, true);
993 break;
994 }
995 default: {
996 DECL_ANCHOR(cond_seq);
997 pm_compile_node(iseq, cond, cond_seq, false, scope_node);
998
999 if (LIST_INSN_SIZE_ONE(cond_seq)) {
1000 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(cond_seq));
1001
1002 if (insn->insn_id == BIN(putobject)) {
1003 if (RTEST(insn->operands[0])) {
1004 PUSH_INSNL(ret, location, jump, then_label);
1005 // maybe unreachable
1006 return;
1007 }
1008 else {
1009 PUSH_INSNL(ret, location, jump, else_label);
1010 return;
1011 }
1012 }
1013 }
1014
1015 PUSH_SEQ(ret, cond_seq);
1016 break;
1017 }
1018 }
1019
1020 PUSH_INSNL(ret, location, branchunless, else_label);
1021 PUSH_INSNL(ret, location, jump, then_label);
1022}
1023
1027static void
1028pm_compile_conditional(rb_iseq_t *iseq, const pm_node_location_t *node_location, pm_node_type_t type, const pm_node_t *node, const pm_statements_node_t *statements, const pm_node_t *subsequent, const pm_node_t *predicate, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
1029{
1030 const pm_node_location_t location = *node_location;
1031 LABEL *then_label = NEW_LABEL(location.line);
1032 LABEL *else_label = NEW_LABEL(location.line);
1033 LABEL *end_label = NULL;
1034
1035 DECL_ANCHOR(cond_seq);
1036 pm_compile_branch_condition(iseq, cond_seq, predicate, then_label, else_label, false, scope_node);
1037 PUSH_SEQ(ret, cond_seq);
1038
1039 rb_code_location_t conditional_location = { 0 };
1040 VALUE branches = Qfalse;
1041
1042 if (then_label->refcnt && else_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1043 conditional_location = pm_code_location(scope_node, node);
1044 branches = decl_branch_base(iseq, PTR2NUM(node), &conditional_location, type == PM_IF_NODE ? "if" : "unless");
1045 }
1046
1047 if (then_label->refcnt) {
1048 PUSH_LABEL(ret, then_label);
1049
1050 DECL_ANCHOR(then_seq);
1051
1052 if (statements != NULL) {
1053 pm_compile_node(iseq, (const pm_node_t *) statements, then_seq, popped, scope_node);
1054 }
1055 else if (!popped) {
1056 PUSH_SYNTHETIC_PUTNIL(then_seq, iseq);
1057 }
1058
1059 if (else_label->refcnt) {
1060 // Establish branch coverage for the then block.
1061 if (PM_BRANCH_COVERAGE_P(iseq)) {
1062 rb_code_location_t branch_location;
1063
1064 if (statements != NULL) {
1065 branch_location = pm_code_location(scope_node, (const pm_node_t *) statements);
1066 } else if (type == PM_IF_NODE) {
1067 pm_line_column_t predicate_end = PM_NODE_END_LINE_COLUMN(scope_node->parser, predicate);
1068 branch_location = (rb_code_location_t) {
1069 .beg_pos = { .lineno = predicate_end.line, .column = predicate_end.column },
1070 .end_pos = { .lineno = predicate_end.line, .column = predicate_end.column }
1071 };
1072 } else {
1073 branch_location = conditional_location;
1074 }
1075
1076 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0, type == PM_IF_NODE ? "then" : "else", branches);
1077 }
1078
1079 end_label = NEW_LABEL(location.line);
1080 PUSH_INSNL(then_seq, location, jump, end_label);
1081 if (!popped) PUSH_INSN(then_seq, location, pop);
1082 }
1083
1084 PUSH_SEQ(ret, then_seq);
1085 }
1086
1087 if (else_label->refcnt) {
1088 PUSH_LABEL(ret, else_label);
1089
1090 DECL_ANCHOR(else_seq);
1091
1092 if (subsequent != NULL) {
1093 pm_compile_node(iseq, subsequent, else_seq, popped, scope_node);
1094 }
1095 else if (!popped) {
1096 PUSH_SYNTHETIC_PUTNIL(else_seq, iseq);
1097 }
1098
1099 // Establish branch coverage for the else block.
1100 if (then_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1101 rb_code_location_t branch_location;
1102
1103 if (subsequent == NULL) {
1104 branch_location = conditional_location;
1105 } else if (PM_NODE_TYPE_P(subsequent, PM_ELSE_NODE)) {
1106 const pm_else_node_t *else_node = (const pm_else_node_t *) subsequent;
1107 branch_location = pm_code_location(scope_node, else_node->statements != NULL ? ((const pm_node_t *) else_node->statements) : (const pm_node_t *) else_node);
1108 } else {
1109 branch_location = pm_code_location(scope_node, (const pm_node_t *) subsequent);
1110 }
1111
1112 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 1, type == PM_IF_NODE ? "else" : "then", branches);
1113 }
1114
1115 PUSH_SEQ(ret, else_seq);
1116 }
1117
1118 if (end_label) {
1119 PUSH_LABEL(ret, end_label);
1120 }
1121
1122 return;
1123}
1124
1128static void
1129pm_compile_loop(rb_iseq_t *iseq, const pm_node_location_t *node_location, pm_node_flags_t flags, enum pm_node_type type, const pm_node_t *node, const pm_statements_node_t *statements, const pm_node_t *predicate, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
1130{
1131 const pm_node_location_t location = *node_location;
1132
1133 LABEL *prev_start_label = ISEQ_COMPILE_DATA(iseq)->start_label;
1134 LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label;
1135 LABEL *prev_redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label;
1136
1137 LABEL *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(location.line); /* next */
1138 LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(location.line); /* redo */
1139 LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(location.line); /* break */
1140 LABEL *end_label = NEW_LABEL(location.line);
1141 LABEL *adjust_label = NEW_LABEL(location.line);
1142
1143 LABEL *next_catch_label = NEW_LABEL(location.line);
1144 LABEL *tmp_label = NULL;
1145
1146 // We're pushing onto the ensure stack because breaks need to break out of
1147 // this loop and not break into the ensure statements within the same
1148 // lexical scope.
1149 struct iseq_compile_data_ensure_node_stack enl;
1150 push_ensure_entry(iseq, &enl, NULL, NULL);
1151
1152 // begin; end while true
1153 if (flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
1154 tmp_label = NEW_LABEL(location.line);
1155 PUSH_INSNL(ret, location, jump, tmp_label);
1156 }
1157 else {
1158 // while true; end
1159 PUSH_INSNL(ret, location, jump, next_label);
1160 }
1161
1162 PUSH_LABEL(ret, adjust_label);
1163 PUSH_INSN(ret, location, putnil);
1164 PUSH_LABEL(ret, next_catch_label);
1165 PUSH_INSN(ret, location, pop);
1166 PUSH_INSNL(ret, location, jump, next_label);
1167 if (tmp_label) PUSH_LABEL(ret, tmp_label);
1168
1169 PUSH_LABEL(ret, redo_label);
1170
1171 // Establish branch coverage for the loop.
1172 if (PM_BRANCH_COVERAGE_P(iseq)) {
1173 rb_code_location_t loop_location = pm_code_location(scope_node, node);
1174 VALUE branches = decl_branch_base(iseq, PTR2NUM(node), &loop_location, type == PM_WHILE_NODE ? "while" : "until");
1175
1176 rb_code_location_t branch_location = statements != NULL ? pm_code_location(scope_node, (const pm_node_t *) statements) : loop_location;
1177 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0, "body", branches);
1178 }
1179
1180 if (statements != NULL) PM_COMPILE_POPPED((const pm_node_t *) statements);
1181 PUSH_LABEL(ret, next_label);
1182
1183 if (type == PM_WHILE_NODE) {
1184 pm_compile_branch_condition(iseq, ret, predicate, redo_label, end_label, popped, scope_node);
1185 }
1186 else if (type == PM_UNTIL_NODE) {
1187 pm_compile_branch_condition(iseq, ret, predicate, end_label, redo_label, popped, scope_node);
1188 }
1189
1190 PUSH_LABEL(ret, end_label);
1191 PUSH_ADJUST_RESTORE(ret, adjust_label);
1192 PUSH_INSN(ret, location, putnil);
1193
1194 PUSH_LABEL(ret, break_label);
1195 if (popped) PUSH_INSN(ret, location, pop);
1196
1197 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label, NULL, break_label);
1198 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, NULL, next_catch_label);
1199 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, NULL, ISEQ_COMPILE_DATA(iseq)->redo_label);
1200
1201 ISEQ_COMPILE_DATA(iseq)->start_label = prev_start_label;
1202 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label;
1203 ISEQ_COMPILE_DATA(iseq)->redo_label = prev_redo_label;
1204 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->prev;
1205
1206 return;
1207}
1208
1209// This recurses through scopes and finds the local index at any scope level
1210// It also takes a pointer to depth, and increments depth appropriately
1211// according to the depth of the local.
1212static pm_local_index_t
1213pm_lookup_local_index(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, pm_constant_id_t constant_id, int start_depth)
1214{
1215 pm_local_index_t lindex = { 0 };
1216 st_data_t local_index;
1217
1218 int level;
1219 for (level = 0; level < start_depth; level++) {
1220 scope_node = scope_node->previous;
1221 }
1222
1223 while (!st_lookup(scope_node->index_lookup_table, constant_id, &local_index)) {
1224 level++;
1225
1226 if (scope_node->previous) {
1227 scope_node = scope_node->previous;
1228 }
1229 else {
1230 // We have recursed up all scope nodes
1231 // and have not found the local yet
1232 rb_bug("Local with constant_id %u does not exist", (unsigned int) constant_id);
1233 }
1234 }
1235
1236 lindex.level = level;
1237 lindex.index = scope_node->local_table_for_iseq_size - (int) local_index;
1238 return lindex;
1239}
1240
1241// This returns the CRuby ID which maps to the pm_constant_id_t
1242//
1243// Constant_ids in prism are indexes of the constants in prism's constant pool.
1244// We add a constants mapping on the scope_node which is a mapping from
1245// these constant_id indexes to the CRuby IDs that they represent.
1246// This helper method allows easy access to those IDs
1247static ID
1248pm_constant_id_lookup(const pm_scope_node_t *scope_node, pm_constant_id_t constant_id)
1249{
1250 if (constant_id < 1 || constant_id > scope_node->parser->constant_pool.size) {
1251 rb_bug("constant_id out of range: %u", (unsigned int)constant_id);
1252 }
1253 return scope_node->constants[constant_id - 1];
1254}
1255
1256static rb_iseq_t *
1257pm_new_child_iseq(rb_iseq_t *iseq, pm_scope_node_t *node, VALUE name, const rb_iseq_t *parent, enum rb_iseq_type type, int line_no)
1258{
1259 debugs("[new_child_iseq]> ---------------------------------------\n");
1260 int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth;
1261 int error_state;
1262 rb_iseq_t *ret_iseq = pm_iseq_new_with_opt(node, name,
1263 rb_iseq_path(iseq), rb_iseq_realpath(iseq),
1264 line_no, parent,
1265 isolated_depth ? isolated_depth + 1 : 0,
1266 type, ISEQ_COMPILE_DATA(iseq)->option, &error_state);
1267
1268 if (error_state) {
1269 pm_scope_node_destroy(node);
1270 RUBY_ASSERT(ret_iseq == NULL);
1271 rb_jump_tag(error_state);
1272 }
1273 debugs("[new_child_iseq]< ---------------------------------------\n");
1274 return ret_iseq;
1275}
1276
1277static int
1278pm_compile_class_path(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
1279{
1280 if (PM_NODE_TYPE_P(node, PM_CONSTANT_PATH_NODE)) {
1281 const pm_node_t *parent = ((const pm_constant_path_node_t *) node)->parent;
1282
1283 if (parent) {
1284 /* Bar::Foo */
1285 PM_COMPILE(parent);
1286 return VM_DEFINECLASS_FLAG_SCOPED;
1287 }
1288 else {
1289 /* toplevel class ::Foo */
1290 PUSH_INSN1(ret, *node_location, putobject, rb_cObject);
1291 return VM_DEFINECLASS_FLAG_SCOPED;
1292 }
1293 }
1294 else {
1295 /* class at cbase Foo */
1296 PUSH_INSN1(ret, *node_location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
1297 return 0;
1298 }
1299}
1300
1305static void
1306pm_compile_call_and_or_write_node(rb_iseq_t *iseq, bool and_node, const pm_node_t *receiver, const pm_node_t *value, pm_constant_id_t write_name, pm_constant_id_t read_name, bool safe_nav, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
1307{
1308 const pm_node_location_t location = *node_location;
1309 LABEL *lfin = NEW_LABEL(location.line);
1310 LABEL *lcfin = NEW_LABEL(location.line);
1311 LABEL *lskip = NULL;
1312
1313 int flag = PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
1314 ID id_read_name = pm_constant_id_lookup(scope_node, read_name);
1315
1316 PM_COMPILE_NOT_POPPED(receiver);
1317 if (safe_nav) {
1318 lskip = NEW_LABEL(location.line);
1319 PUSH_INSN(ret, location, dup);
1320 PUSH_INSNL(ret, location, branchnil, lskip);
1321 }
1322
1323 PUSH_INSN(ret, location, dup);
1324 PUSH_SEND_WITH_FLAG(ret, location, id_read_name, INT2FIX(0), INT2FIX(flag));
1325 if (!popped) PUSH_INSN(ret, location, dup);
1326
1327 if (and_node) {
1328 PUSH_INSNL(ret, location, branchunless, lcfin);
1329 }
1330 else {
1331 PUSH_INSNL(ret, location, branchif, lcfin);
1332 }
1333
1334 if (!popped) PUSH_INSN(ret, location, pop);
1335 PM_COMPILE_NOT_POPPED(value);
1336
1337 if (!popped) {
1338 PUSH_INSN(ret, location, swap);
1339 PUSH_INSN1(ret, location, topn, INT2FIX(1));
1340 }
1341
1342 ID id_write_name = pm_constant_id_lookup(scope_node, write_name);
1343 PUSH_SEND_WITH_FLAG(ret, location, id_write_name, INT2FIX(1), INT2FIX(flag));
1344 PUSH_INSNL(ret, location, jump, lfin);
1345
1346 PUSH_LABEL(ret, lcfin);
1347 if (!popped) PUSH_INSN(ret, location, swap);
1348
1349 PUSH_LABEL(ret, lfin);
1350
1351 if (lskip && popped) PUSH_LABEL(ret, lskip);
1352 PUSH_INSN(ret, location, pop);
1353 if (lskip && !popped) PUSH_LABEL(ret, lskip);
1354}
1355
1356static void pm_compile_shareable_constant_value(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_flags_t shareability, VALUE path, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node, bool top);
1357
1363static void
1364pm_compile_hash_elements(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_list_t *elements, const pm_node_flags_t shareability, VALUE path, bool argument, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node)
1365{
1366 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
1367
1368 // If this element is not popped, then we need to create the hash on the
1369 // stack. Neighboring plain assoc nodes should be grouped together (either
1370 // by newhash or hash merge). Double splat nodes should be merged using the
1371 // merge_kwd method call.
1372 const int max_stack_length = 0x100;
1373 const unsigned int min_tmp_hash_length = 0x800;
1374
1375 int stack_length = 0;
1376 bool first_chunk = true;
1377
1378 // This is an optimization wherein we keep track of whether or not the
1379 // previous element was a static literal. If it was, then we do not attempt
1380 // to check if we have a subhash that can be optimized. If it was not, then
1381 // we do check.
1382 bool static_literal = false;
1383
1384 DECL_ANCHOR(anchor);
1385
1386 // Convert pushed elements to a hash, and merge if needed.
1387#define FLUSH_CHUNK \
1388 if (stack_length) { \
1389 if (first_chunk) { \
1390 PUSH_SEQ(ret, anchor); \
1391 PUSH_INSN1(ret, location, newhash, INT2FIX(stack_length)); \
1392 first_chunk = false; \
1393 } \
1394 else { \
1395 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); \
1396 PUSH_INSN(ret, location, swap); \
1397 PUSH_SEQ(ret, anchor); \
1398 PUSH_SEND(ret, location, id_core_hash_merge_ptr, INT2FIX(stack_length + 1)); \
1399 } \
1400 INIT_ANCHOR(anchor); \
1401 stack_length = 0; \
1402 }
1403
1404 for (size_t index = 0; index < elements->size; index++) {
1405 const pm_node_t *element = elements->nodes[index];
1406
1407 switch (PM_NODE_TYPE(element)) {
1408 case PM_ASSOC_NODE: {
1409 // Pre-allocation check (this branch can be omitted).
1410 if (
1411 (shareability == 0) &&
1412 PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL) && (
1413 (!static_literal && ((index + min_tmp_hash_length) < elements->size)) ||
1414 (first_chunk && stack_length == 0)
1415 )
1416 ) {
1417 // Count the elements that are statically-known.
1418 size_t count = 1;
1419 while (index + count < elements->size && PM_NODE_FLAG_P(elements->nodes[index + count], PM_NODE_FLAG_STATIC_LITERAL)) count++;
1420
1421 if ((first_chunk && stack_length == 0) || count >= min_tmp_hash_length) {
1422 // The subsequence of elements in this hash is long enough
1423 // to merit its own hash.
1424 VALUE ary = rb_ary_hidden_new(count);
1425
1426 // Create a hidden hash.
1427 for (size_t tmp_end = index + count; index < tmp_end; index++) {
1428 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[index];
1429
1430 VALUE elem[2] = {
1431 pm_static_literal_value(iseq, assoc->key, scope_node),
1432 pm_static_literal_value(iseq, assoc->value, scope_node)
1433 };
1434
1435 rb_ary_cat(ary, elem, 2);
1436 }
1437 index --;
1438
1439 VALUE hash = rb_hash_new_with_size(RARRAY_LEN(ary) / 2);
1440 rb_hash_bulk_insert(RARRAY_LEN(ary), RARRAY_CONST_PTR(ary), hash);
1441 hash = rb_obj_hide(hash);
1442 OBJ_FREEZE(hash);
1443
1444 // Emit optimized code.
1445 FLUSH_CHUNK;
1446 if (first_chunk) {
1447 PUSH_INSN1(ret, location, duphash, hash);
1448 first_chunk = false;
1449 }
1450 else {
1451 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1452 PUSH_INSN(ret, location, swap);
1453 PUSH_INSN1(ret, location, putobject, hash);
1454 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1455 }
1456
1457 break;
1458 }
1459 else {
1460 static_literal = true;
1461 }
1462 }
1463 else {
1464 static_literal = false;
1465 }
1466
1467 // If this is a plain assoc node, then we can compile it directly
1468 // and then add the total number of values on the stack.
1469 if (shareability == 0) {
1470 pm_compile_node(iseq, element, anchor, false, scope_node);
1471 }
1472 else {
1473 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
1474 pm_compile_shareable_constant_value(iseq, assoc->key, shareability, path, ret, scope_node, false);
1475 pm_compile_shareable_constant_value(iseq, assoc->value, shareability, path, ret, scope_node, false);
1476 }
1477
1478 if ((stack_length += 2) >= max_stack_length) FLUSH_CHUNK;
1479 break;
1480 }
1481 case PM_ASSOC_SPLAT_NODE: {
1482 FLUSH_CHUNK;
1483
1484 const pm_assoc_splat_node_t *assoc_splat = (const pm_assoc_splat_node_t *) element;
1485 bool empty_hash = assoc_splat->value != NULL && (
1486 (PM_NODE_TYPE_P(assoc_splat->value, PM_HASH_NODE) && ((const pm_hash_node_t *) assoc_splat->value)->elements.size == 0) ||
1487 PM_NODE_TYPE_P(assoc_splat->value, PM_NIL_NODE)
1488 );
1489
1490 bool first_element = first_chunk && stack_length == 0;
1491 bool last_element = index == elements->size - 1;
1492 bool only_element = first_element && last_element;
1493
1494 if (empty_hash) {
1495 if (only_element && argument) {
1496 // **{} appears at the only keyword argument in method call,
1497 // so it won't be modified.
1498 //
1499 // This is only done for method calls and not for literal
1500 // hashes, because literal hashes should always result in a
1501 // new hash.
1502 PUSH_INSN(ret, location, putnil);
1503 }
1504 else if (first_element) {
1505 // **{} appears as the first keyword argument, so it may be
1506 // modified. We need to create a fresh hash object.
1507 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1508 }
1509 // Any empty keyword splats that are not the first can be
1510 // ignored since merging an empty hash into the existing hash is
1511 // the same as not merging it.
1512 }
1513 else {
1514 if (only_element && argument) {
1515 // ** is only keyword argument in the method call. Use it
1516 // directly. This will be not be flagged as mutable. This is
1517 // only done for method calls and not for literal hashes,
1518 // because literal hashes should always result in a new
1519 // hash.
1520 if (shareability == 0) {
1521 PM_COMPILE_NOT_POPPED(element);
1522 }
1523 else {
1524 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node, false);
1525 }
1526 }
1527 else {
1528 // There is more than one keyword argument, or this is not a
1529 // method call. In that case, we need to add an empty hash
1530 // (if first keyword), or merge the hash to the accumulated
1531 // hash (if not the first keyword).
1532 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1533
1534 if (first_element) {
1535 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1536 }
1537 else {
1538 PUSH_INSN(ret, location, swap);
1539 }
1540
1541 if (shareability == 0) {
1542 PM_COMPILE_NOT_POPPED(element);
1543 }
1544 else {
1545 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node, false);
1546 }
1547
1548 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1549 }
1550 }
1551
1552 first_chunk = false;
1553 static_literal = false;
1554 break;
1555 }
1556 default:
1557 RUBY_ASSERT("Invalid node type for hash" && false);
1558 break;
1559 }
1560 }
1561
1562 FLUSH_CHUNK;
1563#undef FLUSH_CHUNK
1564}
1565
1566#define SPLATARRAY_FALSE 0
1567#define SPLATARRAY_TRUE 1
1568#define DUP_SINGLE_KW_SPLAT 2
1569
1570// This is details. Users should call pm_setup_args() instead.
1571static int
1572pm_setup_args_core(const pm_arguments_node_t *arguments_node, const pm_node_t *block, int *flags, const bool has_regular_blockarg, struct rb_callinfo_kwarg **kw_arg, int *dup_rest, rb_iseq_t *iseq, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node, const pm_node_location_t *node_location)
1573{
1574 const pm_node_location_t location = *node_location;
1575
1576 int orig_argc = 0;
1577 bool has_splat = false;
1578 bool has_keyword_splat = false;
1579
1580 if (arguments_node == NULL) {
1581 if (*flags & VM_CALL_FCALL) {
1582 *flags |= VM_CALL_VCALL;
1583 }
1584 }
1585 else {
1586 const pm_node_list_t *arguments = &arguments_node->arguments;
1587 has_keyword_splat = PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT);
1588
1589 // We count the number of elements post the splat node that are not keyword elements to
1590 // eventually pass as an argument to newarray
1591 int post_splat_counter = 0;
1592 const pm_node_t *argument;
1593
1594 PM_NODE_LIST_FOREACH(arguments, index, argument) {
1595 switch (PM_NODE_TYPE(argument)) {
1596 // A keyword hash node contains all keyword arguments as AssocNodes and AssocSplatNodes
1597 case PM_KEYWORD_HASH_NODE: {
1598 const pm_keyword_hash_node_t *keyword_arg = (const pm_keyword_hash_node_t *) argument;
1599 const pm_node_list_t *elements = &keyword_arg->elements;
1600
1601 if (has_keyword_splat || has_splat) {
1602 *flags |= VM_CALL_KW_SPLAT;
1603 has_keyword_splat = true;
1604
1605 if (elements->size > 1 || !(elements->size == 1 && PM_NODE_TYPE_P(elements->nodes[0], PM_ASSOC_SPLAT_NODE))) {
1606 // A new hash will be created for the keyword arguments
1607 // in this case, so mark the method as passing mutable
1608 // keyword splat.
1609 *flags |= VM_CALL_KW_SPLAT_MUT;
1610 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1611 }
1612 else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
1613 *flags |= VM_CALL_KW_SPLAT_MUT;
1614 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1615 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1616 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1617 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1618 }
1619 else {
1620 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1621 }
1622 }
1623 else {
1624 // We need to first figure out if all elements of the
1625 // KeywordHashNode are AssocNodes with symbol keys.
1626 if (PM_NODE_FLAG_P(keyword_arg, PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS)) {
1627 // If they are all symbol keys then we can pass them as
1628 // keyword arguments. The first thing we need to do is
1629 // deduplicate. We'll do this using the combination of a
1630 // Ruby hash and a Ruby array.
1631 VALUE stored_indices = rb_hash_new();
1632 VALUE keyword_indices = rb_ary_new_capa(elements->size);
1633
1634 size_t size = 0;
1635 for (size_t element_index = 0; element_index < elements->size; element_index++) {
1636 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1637
1638 // Retrieve the stored index from the hash for this
1639 // keyword.
1640 VALUE keyword = pm_static_literal_value(iseq, assoc->key, scope_node);
1641 VALUE stored_index = rb_hash_aref(stored_indices, keyword);
1642
1643 // If this keyword was already seen in the hash,
1644 // then mark the array at that index as false and
1645 // decrement the keyword size.
1646 if (!NIL_P(stored_index)) {
1647 rb_ary_store(keyword_indices, NUM2LONG(stored_index), Qfalse);
1648 size--;
1649 }
1650
1651 // Store (and possibly overwrite) the index for this
1652 // keyword in the hash, mark the array at that index
1653 // as true, and increment the keyword size.
1654 rb_hash_aset(stored_indices, keyword, ULONG2NUM(element_index));
1655 rb_ary_store(keyword_indices, (long) element_index, Qtrue);
1656 size++;
1657 }
1658
1659 *kw_arg = rb_xmalloc_mul_add(size, sizeof(VALUE), sizeof(struct rb_callinfo_kwarg));
1660 *flags |= VM_CALL_KWARG;
1661
1662 VALUE *keywords = (*kw_arg)->keywords;
1663 (*kw_arg)->references = 0;
1664 (*kw_arg)->keyword_len = (int) size;
1665
1666 size_t keyword_index = 0;
1667 for (size_t element_index = 0; element_index < elements->size; element_index++) {
1668 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1669 bool popped = true;
1670
1671 if (rb_ary_entry(keyword_indices, (long) element_index) == Qtrue) {
1672 keywords[keyword_index++] = pm_static_literal_value(iseq, assoc->key, scope_node);
1673 popped = false;
1674 }
1675
1676 PM_COMPILE(assoc->value);
1677 }
1678
1679 RUBY_ASSERT(keyword_index == size);
1680 }
1681 else {
1682 // If they aren't all symbol keys then we need to
1683 // construct a new hash and pass that as an argument.
1684 orig_argc++;
1685 *flags |= VM_CALL_KW_SPLAT;
1686
1687 size_t size = elements->size;
1688 if (size > 1) {
1689 // A new hash will be created for the keyword
1690 // arguments in this case, so mark the method as
1691 // passing mutable keyword splat.
1692 *flags |= VM_CALL_KW_SPLAT_MUT;
1693 }
1694
1695 for (size_t element_index = 0; element_index < size; element_index++) {
1696 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1697 PM_COMPILE_NOT_POPPED(assoc->key);
1698 PM_COMPILE_NOT_POPPED(assoc->value);
1699 }
1700
1701 PUSH_INSN1(ret, location, newhash, INT2FIX(size * 2));
1702 }
1703 }
1704 break;
1705 }
1706 case PM_SPLAT_NODE: {
1707 *flags |= VM_CALL_ARGS_SPLAT;
1708 const pm_splat_node_t *splat_node = (const pm_splat_node_t *) argument;
1709
1710 if (splat_node->expression) {
1711 PM_COMPILE_NOT_POPPED(splat_node->expression);
1712 }
1713 else {
1714 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1715 PUSH_GETLOCAL(ret, location, index.index, index.level);
1716 }
1717
1718 bool first_splat = !has_splat;
1719
1720 if (first_splat) {
1721 // If this is the first splat array seen and it's not the
1722 // last parameter, we want splatarray to dup it.
1723 //
1724 // foo(a, *b, c)
1725 // ^^
1726 if (index + 1 < arguments->size || has_regular_blockarg) {
1727 PUSH_INSN1(ret, location, splatarray, (*dup_rest & SPLATARRAY_TRUE) ? Qtrue : Qfalse);
1728 if (*dup_rest & SPLATARRAY_TRUE) *dup_rest &= ~SPLATARRAY_TRUE;
1729 }
1730 // If this is the first spalt array seen and it's the last
1731 // parameter, we don't want splatarray to dup it.
1732 //
1733 // foo(a, *b)
1734 // ^^
1735 else {
1736 PUSH_INSN1(ret, location, splatarray, Qfalse);
1737 }
1738 }
1739 else {
1740 // If this is not the first splat array seen and it is also
1741 // the last parameter, we don't want splatarray to dup it
1742 // and we need to concat the array.
1743 //
1744 // foo(a, *b, *c)
1745 // ^^
1746 PUSH_INSN(ret, location, concattoarray);
1747 }
1748
1749 has_splat = true;
1750 post_splat_counter = 0;
1751
1752 break;
1753 }
1754 case PM_FORWARDING_ARGUMENTS_NODE: { // not counted in argc return value
1755 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
1756
1757 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
1758 *flags |= VM_CALL_FORWARDING;
1759
1760 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
1761 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1762
1763 break;
1764 }
1765
1766 orig_argc += 2;
1767
1768 *flags |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT | VM_CALL_ARGS_BLOCKARG | VM_CALL_KW_SPLAT;
1769
1770 // Forwarding arguments nodes are treated as foo(*, **, &)
1771 // So foo(...) equals foo(*, **, &) and as such the local
1772 // table for this method is known in advance
1773 //
1774 // Push the *
1775 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1776 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1777 PUSH_INSN1(ret, location, splatarray, Qtrue);
1778
1779 // Push the **
1780 pm_local_index_t pow_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
1781 PUSH_GETLOCAL(ret, location, pow_local.index, pow_local.level);
1782
1783 // Push the &
1784 pm_local_index_t and_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
1785 PUSH_INSN2(ret, location, getblockparamproxy, INT2FIX(and_local.index + VM_ENV_DATA_SIZE - 1), INT2FIX(and_local.level));
1786 PUSH_INSN(ret, location, splatkw);
1787
1788 break;
1789 }
1790 default: {
1791 post_splat_counter++;
1792 PM_COMPILE_NOT_POPPED(argument);
1793
1794 // If we have a splat and we've seen a splat, we need to process
1795 // everything after the splat.
1796 if (has_splat) {
1797 // Stack items are turned into an array and concatenated in
1798 // the following cases:
1799 //
1800 // If the next node is a splat:
1801 //
1802 // foo(*a, b, *c)
1803 //
1804 // If the next node is a kwarg or kwarg splat:
1805 //
1806 // foo(*a, b, c: :d)
1807 // foo(*a, b, **c)
1808 //
1809 // If the next node is NULL (we have hit the end):
1810 //
1811 // foo(*a, b)
1812 if (index == arguments->size - 1) {
1813 RUBY_ASSERT(post_splat_counter > 0);
1814 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(post_splat_counter));
1815 }
1816 else {
1817 pm_node_t *next_arg = arguments->nodes[index + 1];
1818
1819 switch (PM_NODE_TYPE(next_arg)) {
1820 // A keyword hash node contains all keyword arguments as AssocNodes and AssocSplatNodes
1821 case PM_KEYWORD_HASH_NODE: {
1822 PUSH_INSN1(ret, location, newarray, INT2FIX(post_splat_counter));
1823 PUSH_INSN(ret, location, concatarray);
1824 break;
1825 }
1826 case PM_SPLAT_NODE: {
1827 PUSH_INSN1(ret, location, newarray, INT2FIX(post_splat_counter));
1828 PUSH_INSN(ret, location, concatarray);
1829 break;
1830 }
1831 default:
1832 break;
1833 }
1834 }
1835 }
1836 else {
1837 orig_argc++;
1838 }
1839 }
1840 }
1841 }
1842 }
1843
1844 if (has_splat) orig_argc++;
1845 if (has_keyword_splat) orig_argc++;
1846 return orig_argc;
1847}
1848
1853static inline bool
1854pm_setup_args_dup_rest_p(const pm_node_t *node)
1855{
1856 switch (PM_NODE_TYPE(node)) {
1857 case PM_BACK_REFERENCE_READ_NODE:
1858 case PM_CLASS_VARIABLE_READ_NODE:
1859 case PM_CONSTANT_READ_NODE:
1860 case PM_FALSE_NODE:
1861 case PM_FLOAT_NODE:
1862 case PM_GLOBAL_VARIABLE_READ_NODE:
1863 case PM_IMAGINARY_NODE:
1864 case PM_INSTANCE_VARIABLE_READ_NODE:
1865 case PM_INTEGER_NODE:
1866 case PM_LAMBDA_NODE:
1867 case PM_LOCAL_VARIABLE_READ_NODE:
1868 case PM_NIL_NODE:
1869 case PM_NUMBERED_REFERENCE_READ_NODE:
1870 case PM_RATIONAL_NODE:
1871 case PM_REGULAR_EXPRESSION_NODE:
1872 case PM_SELF_NODE:
1873 case PM_STRING_NODE:
1874 case PM_SYMBOL_NODE:
1875 case PM_TRUE_NODE:
1876 return false;
1877 case PM_CONSTANT_PATH_NODE: {
1878 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
1879 if (cast->parent != NULL) {
1880 return pm_setup_args_dup_rest_p(cast->parent);
1881 }
1882 return false;
1883 }
1884 case PM_IMPLICIT_NODE:
1885 return pm_setup_args_dup_rest_p(((const pm_implicit_node_t *) node)->value);
1886 default:
1887 return true;
1888 }
1889}
1890
1894static int
1895pm_setup_args(const pm_arguments_node_t *arguments_node, const pm_node_t *block, int *flags, struct rb_callinfo_kwarg **kw_arg, rb_iseq_t *iseq, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node, const pm_node_location_t *node_location)
1896{
1897 int dup_rest = SPLATARRAY_TRUE;
1898
1899 const pm_node_list_t *arguments;
1900 size_t arguments_size;
1901
1902 // Calls like foo(1, *f, **hash) that use splat and kwsplat could be
1903 // eligible for eliding duping the rest array (dup_reset=false).
1904 if (
1905 arguments_node != NULL &&
1906 (arguments = &arguments_node->arguments, arguments_size = arguments->size) >= 2 &&
1907 PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT) &&
1908 !PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS) &&
1909 PM_NODE_TYPE_P(arguments->nodes[arguments_size - 1], PM_KEYWORD_HASH_NODE)
1910 ) {
1911 // Start by assuming that dup_rest=false, then check each element of the
1912 // hash to ensure we don't need to flip it back to true (in case one of
1913 // the elements could potentially mutate the array).
1914 dup_rest = SPLATARRAY_FALSE;
1915
1916 const pm_keyword_hash_node_t *keyword_hash = (const pm_keyword_hash_node_t *) arguments->nodes[arguments_size - 1];
1917 const pm_node_list_t *elements = &keyword_hash->elements;
1918
1919 for (size_t index = 0; dup_rest == SPLATARRAY_FALSE && index < elements->size; index++) {
1920 const pm_node_t *element = elements->nodes[index];
1921
1922 switch (PM_NODE_TYPE(element)) {
1923 case PM_ASSOC_NODE: {
1924 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
1925 if (pm_setup_args_dup_rest_p(assoc->key) || pm_setup_args_dup_rest_p(assoc->value)) dup_rest = SPLATARRAY_TRUE;
1926 break;
1927 }
1928 case PM_ASSOC_SPLAT_NODE: {
1929 const pm_assoc_splat_node_t *assoc = (const pm_assoc_splat_node_t *) element;
1930 if (assoc->value != NULL && pm_setup_args_dup_rest_p(assoc->value)) dup_rest = SPLATARRAY_TRUE;
1931 break;
1932 }
1933 default:
1934 break;
1935 }
1936 }
1937 }
1938
1939 int initial_dup_rest = dup_rest;
1940 int argc;
1941
1942 if (block && PM_NODE_TYPE_P(block, PM_BLOCK_ARGUMENT_NODE)) {
1943 // We compile the `&block_arg` expression first and stitch it later
1944 // since the nature of the expression influences whether splat should
1945 // duplicate the array.
1946 bool regular_block_arg = true;
1947 const pm_node_t *block_expr = ((const pm_block_argument_node_t *)block)->expression;
1948
1949 if (block_expr && pm_setup_args_dup_rest_p(block_expr)) {
1950 dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
1951 initial_dup_rest = dup_rest;
1952 }
1953
1954 DECL_ANCHOR(block_arg);
1955 pm_compile_node(iseq, block, block_arg, false, scope_node);
1956
1957 *flags |= VM_CALL_ARGS_BLOCKARG;
1958
1959 if (LIST_INSN_SIZE_ONE(block_arg)) {
1960 LINK_ELEMENT *elem = FIRST_ELEMENT(block_arg);
1961 if (IS_INSN(elem)) {
1962 INSN *iobj = (INSN *) elem;
1963 if (iobj->insn_id == BIN(getblockparam)) {
1964 iobj->insn_id = BIN(getblockparamproxy);
1965 }
1966
1967 // Allow splat without duplication for simple one-instruction
1968 // block arguments like `&arg`. It is known that this
1969 // optimization can be too aggressive in some cases. See
1970 // [Bug #16504].
1971 regular_block_arg = false;
1972 }
1973 }
1974
1975 argc = pm_setup_args_core(arguments_node, block, flags, regular_block_arg, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1976 PUSH_SEQ(ret, block_arg);
1977 }
1978 else {
1979 argc = pm_setup_args_core(arguments_node, block, flags, false, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1980 }
1981
1982 // If the dup_rest flag was consumed while compiling the arguments (which
1983 // effectively means we found the splat node), then it would have changed
1984 // during the call to pm_setup_args_core. In this case, we want to add the
1985 // VM_CALL_ARGS_SPLAT_MUT flag.
1986 if (*flags & VM_CALL_ARGS_SPLAT && dup_rest != initial_dup_rest) {
1987 *flags |= VM_CALL_ARGS_SPLAT_MUT;
1988 }
1989
1990 return argc;
1991}
1992
2003static void
2004pm_compile_index_operator_write_node(rb_iseq_t *iseq, const pm_index_operator_write_node_t *node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
2005{
2006 const pm_node_location_t location = *node_location;
2007 if (!popped) PUSH_INSN(ret, location, putnil);
2008
2009 PM_COMPILE_NOT_POPPED(node->receiver);
2010
2011 int boff = (node->block == NULL ? 0 : 1);
2012 int flag = PM_NODE_TYPE_P(node->receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
2013 struct rb_callinfo_kwarg *keywords = NULL;
2014 int argc = pm_setup_args(node->arguments, (const pm_node_t *) node->block, &flag, &keywords, iseq, ret, scope_node, node_location);
2015
2016 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2017 if (boff) {
2018 PUSH_INSN(ret, location, splatkw);
2019 }
2020 else {
2021 PUSH_INSN(ret, location, dup);
2022 PUSH_INSN(ret, location, splatkw);
2023 PUSH_INSN(ret, location, pop);
2024 }
2025 }
2026
2027 int dup_argn = argc + 1 + boff;
2028 int keyword_len = 0;
2029
2030 if (keywords) {
2031 keyword_len = keywords->keyword_len;
2032 dup_argn += keyword_len;
2033 }
2034
2035 PUSH_INSN1(ret, location, dupn, INT2FIX(dup_argn));
2036 PUSH_SEND_R(ret, location, idAREF, INT2FIX(argc), NULL, INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2037 PM_COMPILE_NOT_POPPED(node->value);
2038
2039 ID id_operator = pm_constant_id_lookup(scope_node, node->binary_operator);
2040 PUSH_SEND(ret, location, id_operator, INT2FIX(1));
2041
2042 if (!popped) {
2043 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2044 }
2045 if (flag & VM_CALL_ARGS_SPLAT) {
2046 if (flag & VM_CALL_KW_SPLAT) {
2047 PUSH_INSN1(ret, location, topn, INT2FIX(2 + boff));
2048
2049 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2050 PUSH_INSN1(ret, location, splatarray, Qtrue);
2051 flag |= VM_CALL_ARGS_SPLAT_MUT;
2052 }
2053
2054 PUSH_INSN(ret, location, swap);
2055 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2056 PUSH_INSN1(ret, location, setn, INT2FIX(2 + boff));
2057 PUSH_INSN(ret, location, pop);
2058 }
2059 else {
2060 if (boff > 0) {
2061 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2062 PUSH_INSN(ret, location, swap);
2063 PUSH_INSN(ret, location, pop);
2064 }
2065 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2066 PUSH_INSN(ret, location, swap);
2067 PUSH_INSN1(ret, location, splatarray, Qtrue);
2068 PUSH_INSN(ret, location, swap);
2069 flag |= VM_CALL_ARGS_SPLAT_MUT;
2070 }
2071 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2072 if (boff > 0) {
2073 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2074 PUSH_INSN(ret, location, pop);
2075 PUSH_INSN(ret, location, pop);
2076 }
2077 }
2078
2079 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc), NULL, INT2FIX(flag), keywords);
2080 }
2081 else if (flag & VM_CALL_KW_SPLAT) {
2082 if (boff > 0) {
2083 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2084 PUSH_INSN(ret, location, swap);
2085 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2086 PUSH_INSN(ret, location, pop);
2087 }
2088 PUSH_INSN(ret, location, swap);
2089 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2090 }
2091 else if (keyword_len) {
2092 PUSH_INSN(ret, location, dup);
2093 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 2));
2094 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 1));
2095 PUSH_INSN(ret, location, pop);
2096 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2097 }
2098 else {
2099 if (boff > 0) {
2100 PUSH_INSN(ret, location, swap);
2101 }
2102 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2103 }
2104
2105 PUSH_INSN(ret, location, pop);
2106}
2107
2120static void
2121pm_compile_index_control_flow_write_node(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_t *receiver, const pm_arguments_node_t *arguments, const pm_block_argument_node_t *block, const pm_node_t *value, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
2122{
2123 const pm_node_location_t location = *node_location;
2124 if (!popped) PUSH_INSN(ret, location, putnil);
2125 PM_COMPILE_NOT_POPPED(receiver);
2126
2127 int boff = (block == NULL ? 0 : 1);
2128 int flag = PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
2129 struct rb_callinfo_kwarg *keywords = NULL;
2130 int argc = pm_setup_args(arguments, (const pm_node_t *) block, &flag, &keywords, iseq, ret, scope_node, node_location);
2131
2132 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2133 if (boff) {
2134 PUSH_INSN(ret, location, splatkw);
2135 }
2136 else {
2137 PUSH_INSN(ret, location, dup);
2138 PUSH_INSN(ret, location, splatkw);
2139 PUSH_INSN(ret, location, pop);
2140 }
2141 }
2142
2143 int dup_argn = argc + 1 + boff;
2144 int keyword_len = 0;
2145
2146 if (keywords) {
2147 keyword_len = keywords->keyword_len;
2148 dup_argn += keyword_len;
2149 }
2150
2151 PUSH_INSN1(ret, location, dupn, INT2FIX(dup_argn));
2152 PUSH_SEND_R(ret, location, idAREF, INT2FIX(argc), NULL, INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2153
2154 LABEL *label = NEW_LABEL(location.line);
2155 LABEL *lfin = NEW_LABEL(location.line);
2156
2157 PUSH_INSN(ret, location, dup);
2158 if (PM_NODE_TYPE_P(node, PM_INDEX_AND_WRITE_NODE)) {
2159 PUSH_INSNL(ret, location, branchunless, label);
2160 }
2161 else {
2162 PUSH_INSNL(ret, location, branchif, label);
2163 }
2164
2165 PUSH_INSN(ret, location, pop);
2166 PM_COMPILE_NOT_POPPED(value);
2167
2168 if (!popped) {
2169 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2170 }
2171
2172 if (flag & VM_CALL_ARGS_SPLAT) {
2173 if (flag & VM_CALL_KW_SPLAT) {
2174 PUSH_INSN1(ret, location, topn, INT2FIX(2 + boff));
2175 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2176 PUSH_INSN1(ret, location, splatarray, Qtrue);
2177 flag |= VM_CALL_ARGS_SPLAT_MUT;
2178 }
2179
2180 PUSH_INSN(ret, location, swap);
2181 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2182 PUSH_INSN1(ret, location, setn, INT2FIX(2 + boff));
2183 PUSH_INSN(ret, location, pop);
2184 }
2185 else {
2186 if (boff > 0) {
2187 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2188 PUSH_INSN(ret, location, swap);
2189 PUSH_INSN(ret, location, pop);
2190 }
2191 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2192 PUSH_INSN(ret, location, swap);
2193 PUSH_INSN1(ret, location, splatarray, Qtrue);
2194 PUSH_INSN(ret, location, swap);
2195 flag |= VM_CALL_ARGS_SPLAT_MUT;
2196 }
2197 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2198 if (boff > 0) {
2199 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2200 PUSH_INSN(ret, location, pop);
2201 PUSH_INSN(ret, location, pop);
2202 }
2203 }
2204
2205 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc), NULL, INT2FIX(flag), keywords);
2206 }
2207 else if (flag & VM_CALL_KW_SPLAT) {
2208 if (boff > 0) {
2209 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2210 PUSH_INSN(ret, location, swap);
2211 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2212 PUSH_INSN(ret, location, pop);
2213 }
2214
2215 PUSH_INSN(ret, location, swap);
2216 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2217 }
2218 else if (keyword_len) {
2219 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 1));
2220 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 0));
2221 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2222 }
2223 else {
2224 if (boff > 0) {
2225 PUSH_INSN(ret, location, swap);
2226 }
2227 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2228 }
2229
2230 PUSH_INSN(ret, location, pop);
2231 PUSH_INSNL(ret, location, jump, lfin);
2232 PUSH_LABEL(ret, label);
2233 if (!popped) {
2234 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2235 }
2236 PUSH_INSN1(ret, location, adjuststack, INT2FIX(dup_argn + 1));
2237 PUSH_LABEL(ret, lfin);
2238}
2239
2240// When we compile a pattern matching expression, we use the stack as a scratch
2241// space to store lots of different values (consider it like we have a pattern
2242// matching function and we need space for a bunch of different local
2243// variables). The "base index" refers to the index on the stack where we
2244// started compiling the pattern matching expression. These offsets from that
2245// base index indicate the location of the various locals we need.
2246#define PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE 0
2247#define PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING 1
2248#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P 2
2249#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE 3
2250#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY 4
2251
2252// A forward declaration because this is the recursive function that handles
2253// compiling a pattern. It can be reentered by nesting patterns, as in the case
2254// of arrays or hashes.
2255static int pm_compile_pattern(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *matched_label, LABEL *unmatched_label, bool in_single_pattern, bool in_alternation_pattern, bool use_deconstructed_cache, unsigned int base_index);
2256
2261static int
2262pm_compile_pattern_generic_error(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, VALUE message, unsigned int base_index)
2263{
2264 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2265 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2266
2267 PUSH_INSN(ret, location, dup);
2268 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2269
2270 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2271 PUSH_INSN1(ret, location, putobject, message);
2272 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2273 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(2));
2274 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2275
2276 PUSH_INSN1(ret, location, putobject, Qfalse);
2277 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2278
2279 PUSH_INSN(ret, location, pop);
2280 PUSH_INSN(ret, location, pop);
2281 PUSH_LABEL(ret, match_succeeded_label);
2282
2283 return COMPILE_OK;
2284}
2285
2291static int
2292pm_compile_pattern_length_error(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, VALUE message, VALUE length, unsigned int base_index)
2293{
2294 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2295 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2296
2297 PUSH_INSN(ret, location, dup);
2298 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2299
2300 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2301 PUSH_INSN1(ret, location, putobject, message);
2302 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2303 PUSH_INSN(ret, location, dup);
2304 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2305 PUSH_INSN1(ret, location, putobject, length);
2306 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(4));
2307 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2308
2309 PUSH_INSN1(ret, location, putobject, Qfalse);
2310 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2311
2312 PUSH_INSN(ret, location, pop);
2313 PUSH_INSN(ret, location, pop);
2314 PUSH_LABEL(ret, match_succeeded_label);
2315
2316 return COMPILE_OK;
2317}
2318
2324static int
2325pm_compile_pattern_eqq_error(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, unsigned int base_index)
2326{
2327 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2328 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2329
2330 PUSH_INSN(ret, location, dup);
2331 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2332 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2333
2334 VALUE operand = rb_fstring_lit("%p === %p does not return true");
2335 PUSH_INSN1(ret, location, putobject, operand);
2336
2337 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2338 PUSH_INSN1(ret, location, topn, INT2FIX(5));
2339 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2340 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2341 PUSH_INSN1(ret, location, putobject, Qfalse);
2342 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2343 PUSH_INSN(ret, location, pop);
2344 PUSH_INSN(ret, location, pop);
2345
2346 PUSH_LABEL(ret, match_succeeded_label);
2347 PUSH_INSN1(ret, location, setn, INT2FIX(2));
2348 PUSH_INSN(ret, location, pop);
2349 PUSH_INSN(ret, location, pop);
2350
2351 return COMPILE_OK;
2352}
2353
2360static int
2361pm_compile_pattern_match(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *unmatched_label, bool in_single_pattern, bool in_alternation_pattern, bool use_deconstructed_cache, unsigned int base_index)
2362{
2363 LABEL *matched_label = NEW_LABEL(pm_node_line_number(scope_node->parser, node));
2364 CHECK(pm_compile_pattern(iseq, scope_node, node, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
2365 PUSH_LABEL(ret, matched_label);
2366 return COMPILE_OK;
2367}
2368
2374static int
2375pm_compile_pattern_deconstruct(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *deconstruct_label, LABEL *match_failed_label, LABEL *deconstructed_label, LABEL *type_error_label, bool in_single_pattern, bool use_deconstructed_cache, unsigned int base_index)
2376{
2377 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2378
2379 if (use_deconstructed_cache) {
2380 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2381 PUSH_INSNL(ret, location, branchnil, deconstruct_label);
2382
2383 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2384 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2385
2386 PUSH_INSN(ret, location, pop);
2387 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE - 1));
2388 PUSH_INSNL(ret, location, jump, deconstructed_label);
2389 }
2390 else {
2391 PUSH_INSNL(ret, location, jump, deconstruct_label);
2392 }
2393
2394 PUSH_LABEL(ret, deconstruct_label);
2395 PUSH_INSN(ret, location, dup);
2396
2397 VALUE operand = ID2SYM(rb_intern("deconstruct"));
2398 PUSH_INSN1(ret, location, putobject, operand);
2399 PUSH_SEND(ret, location, idRespond_to, INT2FIX(1));
2400
2401 if (use_deconstructed_cache) {
2402 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE + 1));
2403 }
2404
2405 if (in_single_pattern) {
2406 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p does not respond to #deconstruct"), base_index + 1));
2407 }
2408
2409 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2410 PUSH_SEND(ret, location, rb_intern("deconstruct"), INT2FIX(0));
2411
2412 if (use_deconstructed_cache) {
2413 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2414 }
2415
2416 PUSH_INSN(ret, location, dup);
2417 PUSH_INSN1(ret, location, checktype, INT2FIX(T_ARRAY));
2418 PUSH_INSNL(ret, location, branchunless, type_error_label);
2419 PUSH_LABEL(ret, deconstructed_label);
2420
2421 return COMPILE_OK;
2422}
2423
2428static int
2429pm_compile_pattern_constant(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *match_failed_label, bool in_single_pattern, unsigned int base_index)
2430{
2431 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2432
2433 PUSH_INSN(ret, location, dup);
2434 PM_COMPILE_NOT_POPPED(node);
2435
2436 if (in_single_pattern) {
2437 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
2438 }
2439 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE));
2440 if (in_single_pattern) {
2441 CHECK(pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 3));
2442 }
2443 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2444 return COMPILE_OK;
2445}
2446
2451static void
2452pm_compile_pattern_error_handler(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *done_label, bool popped)
2453{
2454 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2455 LABEL *key_error_label = NEW_LABEL(location.line);
2456 LABEL *cleanup_label = NEW_LABEL(location.line);
2457
2458 struct rb_callinfo_kwarg *kw_arg = rb_xmalloc_mul_add(2, sizeof(VALUE), sizeof(struct rb_callinfo_kwarg));
2459 kw_arg->references = 0;
2460 kw_arg->keyword_len = 2;
2461 kw_arg->keywords[0] = ID2SYM(rb_intern("matchee"));
2462 kw_arg->keywords[1] = ID2SYM(rb_intern("key"));
2463
2464 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2465 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2466 PUSH_INSNL(ret, location, branchif, key_error_label);
2467
2468 PUSH_INSN1(ret, location, putobject, rb_eNoMatchingPatternError);
2469 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2470
2471 {
2472 VALUE operand = rb_fstring_lit("%p: %s");
2473 PUSH_INSN1(ret, location, putobject, operand);
2474 }
2475
2476 PUSH_INSN1(ret, location, topn, INT2FIX(4));
2477 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2478 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2479 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2480 PUSH_INSNL(ret, location, jump, cleanup_label);
2481
2482 PUSH_LABEL(ret, key_error_label);
2483 PUSH_INSN1(ret, location, putobject, rb_eNoMatchingPatternKeyError);
2484 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2485
2486 {
2487 VALUE operand = rb_fstring_lit("%p: %s");
2488 PUSH_INSN1(ret, location, putobject, operand);
2489 }
2490
2491 PUSH_INSN1(ret, location, topn, INT2FIX(4));
2492 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2493 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2494 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2495 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2496 PUSH_SEND_R(ret, location, rb_intern("new"), INT2FIX(1), NULL, INT2FIX(VM_CALL_KWARG), kw_arg);
2497 PUSH_SEND(ret, location, id_core_raise, INT2FIX(1));
2498 PUSH_LABEL(ret, cleanup_label);
2499
2500 PUSH_INSN1(ret, location, adjuststack, INT2FIX(7));
2501 if (!popped) PUSH_INSN(ret, location, putnil);
2502 PUSH_INSNL(ret, location, jump, done_label);
2503 PUSH_INSN1(ret, location, dupn, INT2FIX(5));
2504 if (popped) PUSH_INSN(ret, location, putnil);
2505}
2506
2510static int
2511pm_compile_pattern(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *matched_label, LABEL *unmatched_label, bool in_single_pattern, bool in_alternation_pattern, bool use_deconstructed_cache, unsigned int base_index)
2512{
2513 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2514
2515 switch (PM_NODE_TYPE(node)) {
2516 case PM_ARRAY_PATTERN_NODE: {
2517 // Array patterns in pattern matching are triggered by using commas in
2518 // a pattern or wrapping it in braces. They are represented by a
2519 // ArrayPatternNode. This looks like:
2520 //
2521 // foo => [1, 2, 3]
2522 //
2523 // It can optionally have a splat in the middle of it, which can
2524 // optionally have a name attached.
2525 const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
2526
2527 const size_t requireds_size = cast->requireds.size;
2528 const size_t posts_size = cast->posts.size;
2529 const size_t minimum_size = requireds_size + posts_size;
2530
2531 bool rest_named = false;
2532 bool use_rest_size = false;
2533
2534 if (cast->rest != NULL) {
2535 rest_named = (PM_NODE_TYPE_P(cast->rest, PM_SPLAT_NODE) && ((const pm_splat_node_t *) cast->rest)->expression != NULL);
2536 use_rest_size = (rest_named || (!rest_named && posts_size > 0));
2537 }
2538
2539 LABEL *match_failed_label = NEW_LABEL(location.line);
2540 LABEL *type_error_label = NEW_LABEL(location.line);
2541 LABEL *deconstruct_label = NEW_LABEL(location.line);
2542 LABEL *deconstructed_label = NEW_LABEL(location.line);
2543
2544 if (use_rest_size) {
2545 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2546 PUSH_INSN(ret, location, swap);
2547 base_index++;
2548 }
2549
2550 if (cast->constant != NULL) {
2551 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2552 }
2553
2554 CHECK(pm_compile_pattern_deconstruct(iseq, scope_node, node, ret, deconstruct_label, match_failed_label, deconstructed_label, type_error_label, in_single_pattern, use_deconstructed_cache, base_index));
2555
2556 PUSH_INSN(ret, location, dup);
2557 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2558 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2559 PUSH_SEND(ret, location, cast->rest == NULL ? idEq : idGE, INT2FIX(1));
2560 if (in_single_pattern) {
2561 VALUE message = cast->rest == NULL ? rb_fstring_lit("%p length mismatch (given %p, expected %p)") : rb_fstring_lit("%p length mismatch (given %p, expected %p+)");
2562 CHECK(pm_compile_pattern_length_error(iseq, scope_node, node, ret, message, INT2FIX(minimum_size), base_index + 1));
2563 }
2564 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2565
2566 for (size_t index = 0; index < requireds_size; index++) {
2567 const pm_node_t *required = cast->requireds.nodes[index];
2568 PUSH_INSN(ret, location, dup);
2569 PUSH_INSN1(ret, location, putobject, INT2FIX(index));
2570 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2571 CHECK(pm_compile_pattern_match(iseq, scope_node, required, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2572 }
2573
2574 if (cast->rest != NULL) {
2575 if (rest_named) {
2576 PUSH_INSN(ret, location, dup);
2577 PUSH_INSN1(ret, location, putobject, INT2FIX(requireds_size));
2578 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2579 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2580 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2581 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2582 PUSH_INSN1(ret, location, setn, INT2FIX(4));
2583 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2584 CHECK(pm_compile_pattern_match(iseq, scope_node, ((const pm_splat_node_t *) cast->rest)->expression, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2585 }
2586 else if (posts_size > 0) {
2587 PUSH_INSN(ret, location, dup);
2588 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2589 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2590 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2591 PUSH_INSN1(ret, location, setn, INT2FIX(2));
2592 PUSH_INSN(ret, location, pop);
2593 }
2594 }
2595
2596 for (size_t index = 0; index < posts_size; index++) {
2597 const pm_node_t *post = cast->posts.nodes[index];
2598 PUSH_INSN(ret, location, dup);
2599
2600 PUSH_INSN1(ret, location, putobject, INT2FIX(requireds_size + index));
2601 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2602 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2603 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2604 CHECK(pm_compile_pattern_match(iseq, scope_node, post, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2605 }
2606
2607 PUSH_INSN(ret, location, pop);
2608 if (use_rest_size) {
2609 PUSH_INSN(ret, location, pop);
2610 }
2611
2612 PUSH_INSNL(ret, location, jump, matched_label);
2613 PUSH_INSN(ret, location, putnil);
2614 if (use_rest_size) {
2615 PUSH_INSN(ret, location, putnil);
2616 }
2617
2618 PUSH_LABEL(ret, type_error_label);
2619 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2620 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2621
2622 {
2623 VALUE operand = rb_fstring_lit("deconstruct must return Array");
2624 PUSH_INSN1(ret, location, putobject, operand);
2625 }
2626
2627 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2628 PUSH_INSN(ret, location, pop);
2629
2630 PUSH_LABEL(ret, match_failed_label);
2631 PUSH_INSN(ret, location, pop);
2632 if (use_rest_size) {
2633 PUSH_INSN(ret, location, pop);
2634 }
2635
2636 PUSH_INSNL(ret, location, jump, unmatched_label);
2637 break;
2638 }
2639 case PM_FIND_PATTERN_NODE: {
2640 // Find patterns in pattern matching are triggered by using commas in
2641 // a pattern or wrapping it in braces and using a splat on both the left
2642 // and right side of the pattern. This looks like:
2643 //
2644 // foo => [*, 1, 2, 3, *]
2645 //
2646 // There can be any number of requireds in the middle. The splats on
2647 // both sides can optionally have names attached.
2648 const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
2649 const size_t size = cast->requireds.size;
2650
2651 LABEL *match_failed_label = NEW_LABEL(location.line);
2652 LABEL *type_error_label = NEW_LABEL(location.line);
2653 LABEL *deconstruct_label = NEW_LABEL(location.line);
2654 LABEL *deconstructed_label = NEW_LABEL(location.line);
2655
2656 if (cast->constant) {
2657 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2658 }
2659
2660 CHECK(pm_compile_pattern_deconstruct(iseq, scope_node, node, ret, deconstruct_label, match_failed_label, deconstructed_label, type_error_label, in_single_pattern, use_deconstructed_cache, base_index));
2661
2662 PUSH_INSN(ret, location, dup);
2663 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2664 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2665 PUSH_SEND(ret, location, idGE, INT2FIX(1));
2666 if (in_single_pattern) {
2667 CHECK(pm_compile_pattern_length_error(iseq, scope_node, node, ret, rb_fstring_lit("%p length mismatch (given %p, expected %p+)"), INT2FIX(size), base_index + 1));
2668 }
2669 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2670
2671 {
2672 LABEL *while_begin_label = NEW_LABEL(location.line);
2673 LABEL *next_loop_label = NEW_LABEL(location.line);
2674 LABEL *find_succeeded_label = NEW_LABEL(location.line);
2675 LABEL *find_failed_label = NEW_LABEL(location.line);
2676
2677 PUSH_INSN(ret, location, dup);
2678 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2679
2680 PUSH_INSN(ret, location, dup);
2681 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2682 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2683 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2684 PUSH_LABEL(ret, while_begin_label);
2685
2686 PUSH_INSN(ret, location, dup);
2687 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2688 PUSH_SEND(ret, location, idLE, INT2FIX(1));
2689 PUSH_INSNL(ret, location, branchunless, find_failed_label);
2690
2691 for (size_t index = 0; index < size; index++) {
2692 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2693 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2694
2695 if (index != 0) {
2696 PUSH_INSN1(ret, location, putobject, INT2FIX(index));
2697 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2698 }
2699
2700 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2701 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->requireds.nodes[index], ret, next_loop_label, in_single_pattern, in_alternation_pattern, false, base_index + 4));
2702 }
2703
2704 const pm_splat_node_t *left = cast->left;
2705
2706 if (left->expression != NULL) {
2707 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2708 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2709 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2710 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2711 CHECK(pm_compile_pattern_match(iseq, scope_node, left->expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 4));
2712 }
2713
2714 RUBY_ASSERT(PM_NODE_TYPE_P(cast->right, PM_SPLAT_NODE));
2715 const pm_splat_node_t *right = (const pm_splat_node_t *) cast->right;
2716
2717 if (right->expression != NULL) {
2718 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2719 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2720 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2721 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2722 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2723 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2724 pm_compile_pattern_match(iseq, scope_node, right->expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 4);
2725 }
2726
2727 PUSH_INSNL(ret, location, jump, find_succeeded_label);
2728
2729 PUSH_LABEL(ret, next_loop_label);
2730 PUSH_INSN1(ret, location, putobject, INT2FIX(1));
2731 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2732 PUSH_INSNL(ret, location, jump, while_begin_label);
2733
2734 PUSH_LABEL(ret, find_failed_label);
2735 PUSH_INSN1(ret, location, adjuststack, INT2FIX(3));
2736 if (in_single_pattern) {
2737 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2738
2739 {
2740 VALUE operand = rb_fstring_lit("%p does not match to find pattern");
2741 PUSH_INSN1(ret, location, putobject, operand);
2742 }
2743
2744 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2745 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(2));
2746 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2747
2748 PUSH_INSN1(ret, location, putobject, Qfalse);
2749 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2750
2751 PUSH_INSN(ret, location, pop);
2752 PUSH_INSN(ret, location, pop);
2753 }
2754 PUSH_INSNL(ret, location, jump, match_failed_label);
2755 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2756
2757 PUSH_LABEL(ret, find_succeeded_label);
2758 PUSH_INSN1(ret, location, adjuststack, INT2FIX(3));
2759 }
2760
2761 PUSH_INSN(ret, location, pop);
2762 PUSH_INSNL(ret, location, jump, matched_label);
2763 PUSH_INSN(ret, location, putnil);
2764
2765 PUSH_LABEL(ret, type_error_label);
2766 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2767 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2768
2769 {
2770 VALUE operand = rb_fstring_lit("deconstruct must return Array");
2771 PUSH_INSN1(ret, location, putobject, operand);
2772 }
2773
2774 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2775 PUSH_INSN(ret, location, pop);
2776
2777 PUSH_LABEL(ret, match_failed_label);
2778 PUSH_INSN(ret, location, pop);
2779 PUSH_INSNL(ret, location, jump, unmatched_label);
2780
2781 break;
2782 }
2783 case PM_HASH_PATTERN_NODE: {
2784 // Hash patterns in pattern matching are triggered by using labels and
2785 // values in a pattern or by using the ** operator. They are represented
2786 // by the HashPatternNode. This looks like:
2787 //
2788 // foo => { a: 1, b: 2, **bar }
2789 //
2790 // It can optionally have an assoc splat in the middle of it, which can
2791 // optionally have a name.
2792 const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
2793
2794 // We don't consider it a "rest" parameter if it's a ** that is unnamed.
2795 bool has_rest = cast->rest != NULL && !(PM_NODE_TYPE_P(cast->rest, PM_ASSOC_SPLAT_NODE) && ((const pm_assoc_splat_node_t *) cast->rest)->value == NULL);
2796 bool has_keys = cast->elements.size > 0 || cast->rest != NULL;
2797
2798 LABEL *match_failed_label = NEW_LABEL(location.line);
2799 LABEL *type_error_label = NEW_LABEL(location.line);
2800 VALUE keys = Qnil;
2801
2802 if (has_keys && !has_rest) {
2803 keys = rb_ary_new_capa(cast->elements.size);
2804
2805 for (size_t index = 0; index < cast->elements.size; index++) {
2806 const pm_node_t *element = cast->elements.nodes[index];
2807 RUBY_ASSERT(PM_NODE_TYPE_P(element, PM_ASSOC_NODE));
2808
2809 const pm_node_t *key = ((const pm_assoc_node_t *) element)->key;
2810 RUBY_ASSERT(PM_NODE_TYPE_P(key, PM_SYMBOL_NODE));
2811
2812 VALUE symbol = ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) key));
2813 rb_ary_push(keys, symbol);
2814 }
2815 }
2816
2817 if (cast->constant) {
2818 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2819 }
2820
2821 PUSH_INSN(ret, location, dup);
2822
2823 {
2824 VALUE operand = ID2SYM(rb_intern("deconstruct_keys"));
2825 PUSH_INSN1(ret, location, putobject, operand);
2826 }
2827
2828 PUSH_SEND(ret, location, idRespond_to, INT2FIX(1));
2829 if (in_single_pattern) {
2830 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p does not respond to #deconstruct_keys"), base_index + 1));
2831 }
2832 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2833
2834 if (NIL_P(keys)) {
2835 PUSH_INSN(ret, location, putnil);
2836 }
2837 else {
2838 PUSH_INSN1(ret, location, duparray, keys);
2839 RB_OBJ_WRITTEN(iseq, Qundef, rb_obj_hide(keys));
2840 }
2841 PUSH_SEND(ret, location, rb_intern("deconstruct_keys"), INT2FIX(1));
2842
2843 PUSH_INSN(ret, location, dup);
2844 PUSH_INSN1(ret, location, checktype, INT2FIX(T_HASH));
2845 PUSH_INSNL(ret, location, branchunless, type_error_label);
2846
2847 if (has_rest) {
2848 PUSH_SEND(ret, location, rb_intern("dup"), INT2FIX(0));
2849 }
2850
2851 if (has_keys) {
2852 DECL_ANCHOR(match_values);
2853
2854 for (size_t index = 0; index < cast->elements.size; index++) {
2855 const pm_node_t *element = cast->elements.nodes[index];
2856 RUBY_ASSERT(PM_NODE_TYPE_P(element, PM_ASSOC_NODE));
2857
2858 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
2859 const pm_node_t *key = assoc->key;
2860 RUBY_ASSERT(PM_NODE_TYPE_P(key, PM_SYMBOL_NODE));
2861
2862 VALUE symbol = ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) key));
2863 PUSH_INSN(ret, location, dup);
2864 PUSH_INSN1(ret, location, putobject, symbol);
2865 PUSH_SEND(ret, location, rb_intern("key?"), INT2FIX(1));
2866
2867 if (in_single_pattern) {
2868 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2869
2870 PUSH_INSN(ret, location, dup);
2871 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2872
2873 {
2874 VALUE operand = rb_str_freeze(rb_sprintf("key not found: %+"PRIsVALUE, symbol));
2875 PUSH_INSN1(ret, location, putobject, operand);
2876 }
2877
2878 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 2));
2879 PUSH_INSN1(ret, location, putobject, Qtrue);
2880 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 3));
2881 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2882 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2883 PUSH_INSN1(ret, location, putobject, symbol);
2884 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2885
2886 PUSH_INSN1(ret, location, adjuststack, INT2FIX(4));
2887 PUSH_LABEL(ret, match_succeeded_label);
2888 }
2889
2890 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2891 PUSH_INSN(match_values, location, dup);
2892 PUSH_INSN1(match_values, location, putobject, symbol);
2893 PUSH_SEND(match_values, location, has_rest ? rb_intern("delete") : idAREF, INT2FIX(1));
2894
2895 const pm_node_t *value = assoc->value;
2896 if (PM_NODE_TYPE_P(value, PM_IMPLICIT_NODE)) {
2897 value = ((const pm_implicit_node_t *) value)->value;
2898 }
2899
2900 CHECK(pm_compile_pattern_match(iseq, scope_node, value, match_values, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2901 }
2902
2903 PUSH_SEQ(ret, match_values);
2904 }
2905 else {
2906 PUSH_INSN(ret, location, dup);
2907 PUSH_SEND(ret, location, idEmptyP, INT2FIX(0));
2908 if (in_single_pattern) {
2909 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p is not empty"), base_index + 1));
2910 }
2911 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2912 }
2913
2914 if (has_rest) {
2915 switch (PM_NODE_TYPE(cast->rest)) {
2916 case PM_NO_KEYWORDS_PARAMETER_NODE: {
2917 PUSH_INSN(ret, location, dup);
2918 PUSH_SEND(ret, location, idEmptyP, INT2FIX(0));
2919 if (in_single_pattern) {
2920 pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("rest of %p is not empty"), base_index + 1);
2921 }
2922 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2923 break;
2924 }
2925 case PM_ASSOC_SPLAT_NODE: {
2926 const pm_assoc_splat_node_t *splat = (const pm_assoc_splat_node_t *) cast->rest;
2927 PUSH_INSN(ret, location, dup);
2928 pm_compile_pattern_match(iseq, scope_node, splat->value, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1);
2929 break;
2930 }
2931 default:
2932 rb_bug("unreachable");
2933 break;
2934 }
2935 }
2936
2937 PUSH_INSN(ret, location, pop);
2938 PUSH_INSNL(ret, location, jump, matched_label);
2939 PUSH_INSN(ret, location, putnil);
2940
2941 PUSH_LABEL(ret, type_error_label);
2942 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2943 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2944
2945 {
2946 VALUE operand = rb_fstring_lit("deconstruct_keys must return Hash");
2947 PUSH_INSN1(ret, location, putobject, operand);
2948 }
2949
2950 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2951 PUSH_INSN(ret, location, pop);
2952
2953 PUSH_LABEL(ret, match_failed_label);
2954 PUSH_INSN(ret, location, pop);
2955 PUSH_INSNL(ret, location, jump, unmatched_label);
2956 break;
2957 }
2958 case PM_CAPTURE_PATTERN_NODE: {
2959 // Capture patterns allow you to pattern match against an element in a
2960 // pattern and also capture the value into a local variable. This looks
2961 // like:
2962 //
2963 // [1] => [Integer => foo]
2964 //
2965 // In this case the `Integer => foo` will be represented by a
2966 // CapturePatternNode, which has both a value (the pattern to match
2967 // against) and a target (the place to write the variable into).
2968 const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
2969
2970 LABEL *match_failed_label = NEW_LABEL(location.line);
2971
2972 PUSH_INSN(ret, location, dup);
2973 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->value, ret, match_failed_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index + 1));
2974 CHECK(pm_compile_pattern(iseq, scope_node, (const pm_node_t *) cast->target, ret, matched_label, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index));
2975 PUSH_INSN(ret, location, putnil);
2976
2977 PUSH_LABEL(ret, match_failed_label);
2978 PUSH_INSN(ret, location, pop);
2979 PUSH_INSNL(ret, location, jump, unmatched_label);
2980
2981 break;
2982 }
2983 case PM_LOCAL_VARIABLE_TARGET_NODE: {
2984 // Local variables can be targeted by placing identifiers in the place
2985 // of a pattern. For example, foo in bar. This results in the value
2986 // being matched being written to that local variable.
2987 const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
2988 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
2989
2990 // If this local variable is being written from within an alternation
2991 // pattern, then it cannot actually be added to the local table since
2992 // it's ambiguous which value should be used. So instead we indicate
2993 // this with a compile error.
2994 if (in_alternation_pattern) {
2995 ID id = pm_constant_id_lookup(scope_node, cast->name);
2996 const char *name = rb_id2name(id);
2997
2998 if (name && strlen(name) > 0 && name[0] != '_') {
2999 COMPILE_ERROR(iseq, location.line, "illegal variable in alternative pattern (%"PRIsVALUE")", rb_id2str(id));
3000 return COMPILE_NG;
3001 }
3002 }
3003
3004 PUSH_SETLOCAL(ret, location, index.index, index.level);
3005 PUSH_INSNL(ret, location, jump, matched_label);
3006 break;
3007 }
3008 case PM_ALTERNATION_PATTERN_NODE: {
3009 // Alternation patterns allow you to specify multiple patterns in a
3010 // single expression using the | operator.
3011 const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
3012
3013 LABEL *matched_left_label = NEW_LABEL(location.line);
3014 LABEL *unmatched_left_label = NEW_LABEL(location.line);
3015
3016 // First, we're going to attempt to match against the left pattern. If
3017 // that pattern matches, then we'll skip matching the right pattern.
3018 PUSH_INSN(ret, location, dup);
3019 CHECK(pm_compile_pattern(iseq, scope_node, cast->left, ret, matched_left_label, unmatched_left_label, in_single_pattern, true, use_deconstructed_cache, base_index + 1));
3020
3021 // If we get here, then we matched on the left pattern. In this case we
3022 // should pop out the duplicate value that we preemptively added to
3023 // match against the right pattern and then jump to the match label.
3024 PUSH_LABEL(ret, matched_left_label);
3025 PUSH_INSN(ret, location, pop);
3026 PUSH_INSNL(ret, location, jump, matched_label);
3027 PUSH_INSN(ret, location, putnil);
3028
3029 // If we get here, then we didn't match on the left pattern. In this
3030 // case we attempt to match against the right pattern.
3031 PUSH_LABEL(ret, unmatched_left_label);
3032 CHECK(pm_compile_pattern(iseq, scope_node, cast->right, ret, matched_label, unmatched_label, in_single_pattern, true, use_deconstructed_cache, base_index));
3033 break;
3034 }
3035 case PM_PARENTHESES_NODE:
3036 // Parentheses are allowed to wrap expressions in pattern matching and
3037 // they do nothing since they can only wrap individual expressions and
3038 // not groups. In this case we'll recurse back into this same function
3039 // with the body of the parentheses.
3040 return pm_compile_pattern(iseq, scope_node, ((const pm_parentheses_node_t *) node)->body, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index);
3041 case PM_PINNED_EXPRESSION_NODE:
3042 // Pinned expressions are a way to match against the value of an
3043 // expression that should be evaluated at runtime. This looks like:
3044 // foo in ^(bar). To compile these, we compile the expression as if it
3045 // were a literal value by falling through to the literal case.
3046 node = ((const pm_pinned_expression_node_t *) node)->expression;
3047 /* fallthrough */
3048 case PM_ARRAY_NODE:
3049 case PM_CLASS_VARIABLE_READ_NODE:
3050 case PM_CONSTANT_PATH_NODE:
3051 case PM_CONSTANT_READ_NODE:
3052 case PM_FALSE_NODE:
3053 case PM_FLOAT_NODE:
3054 case PM_GLOBAL_VARIABLE_READ_NODE:
3055 case PM_IMAGINARY_NODE:
3056 case PM_INSTANCE_VARIABLE_READ_NODE:
3057 case PM_IT_LOCAL_VARIABLE_READ_NODE:
3058 case PM_INTEGER_NODE:
3059 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
3060 case PM_INTERPOLATED_STRING_NODE:
3061 case PM_INTERPOLATED_SYMBOL_NODE:
3062 case PM_INTERPOLATED_X_STRING_NODE:
3063 case PM_LAMBDA_NODE:
3064 case PM_LOCAL_VARIABLE_READ_NODE:
3065 case PM_NIL_NODE:
3066 case PM_SOURCE_ENCODING_NODE:
3067 case PM_SOURCE_FILE_NODE:
3068 case PM_SOURCE_LINE_NODE:
3069 case PM_RANGE_NODE:
3070 case PM_RATIONAL_NODE:
3071 case PM_REGULAR_EXPRESSION_NODE:
3072 case PM_SELF_NODE:
3073 case PM_STRING_NODE:
3074 case PM_SYMBOL_NODE:
3075 case PM_TRUE_NODE:
3076 case PM_X_STRING_NODE: {
3077 // These nodes are all simple patterns, which means we'll use the
3078 // checkmatch instruction to match against them, which is effectively a
3079 // VM-level === operator.
3080 PM_COMPILE_NOT_POPPED(node);
3081 if (in_single_pattern) {
3082 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
3083 }
3084
3085 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE));
3086
3087 if (in_single_pattern) {
3088 pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 2);
3089 }
3090
3091 PUSH_INSNL(ret, location, branchif, matched_label);
3092 PUSH_INSNL(ret, location, jump, unmatched_label);
3093 break;
3094 }
3095 case PM_PINNED_VARIABLE_NODE: {
3096 // Pinned variables are a way to match against the value of a variable
3097 // without it looking like you're trying to write to the variable. This
3098 // looks like: foo in ^@bar. To compile these, we compile the variable
3099 // that they hold.
3100 const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
3101 CHECK(pm_compile_pattern(iseq, scope_node, cast->variable, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, true, base_index));
3102 break;
3103 }
3104 case PM_IF_NODE:
3105 case PM_UNLESS_NODE: {
3106 // If and unless nodes can show up here as guards on `in` clauses. This
3107 // looks like:
3108 //
3109 // case foo
3110 // in bar if baz?
3111 // qux
3112 // end
3113 //
3114 // Because we know they're in the modifier form and they can't have any
3115 // variation on this pattern, we compile them differently (more simply)
3116 // here than we would in the normal compilation path.
3117 const pm_node_t *predicate;
3118 const pm_node_t *statement;
3119
3120 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3121 const pm_if_node_t *cast = (const pm_if_node_t *) node;
3122 predicate = cast->predicate;
3123
3124 RUBY_ASSERT(cast->statements != NULL && cast->statements->body.size == 1);
3125 statement = cast->statements->body.nodes[0];
3126 }
3127 else {
3128 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
3129 predicate = cast->predicate;
3130
3131 RUBY_ASSERT(cast->statements != NULL && cast->statements->body.size == 1);
3132 statement = cast->statements->body.nodes[0];
3133 }
3134
3135 CHECK(pm_compile_pattern_match(iseq, scope_node, statement, ret, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
3136 PM_COMPILE_NOT_POPPED(predicate);
3137
3138 if (in_single_pattern) {
3139 LABEL *match_succeeded_label = NEW_LABEL(location.line);
3140
3141 PUSH_INSN(ret, location, dup);
3142 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3143 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
3144 }
3145 else {
3146 PUSH_INSNL(ret, location, branchunless, match_succeeded_label);
3147 }
3148
3149 {
3150 VALUE operand = rb_fstring_lit("guard clause does not return true");
3151 PUSH_INSN1(ret, location, putobject, operand);
3152 }
3153
3154 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
3155 PUSH_INSN1(ret, location, putobject, Qfalse);
3156 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
3157
3158 PUSH_INSN(ret, location, pop);
3159 PUSH_INSN(ret, location, pop);
3160
3161 PUSH_LABEL(ret, match_succeeded_label);
3162 }
3163
3164 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3165 PUSH_INSNL(ret, location, branchunless, unmatched_label);
3166 }
3167 else {
3168 PUSH_INSNL(ret, location, branchif, unmatched_label);
3169 }
3170
3171 PUSH_INSNL(ret, location, jump, matched_label);
3172 break;
3173 }
3174 default:
3175 // If we get here, then we have a node type that should not be in this
3176 // position. This would be a bug in the parser, because a different node
3177 // type should never have been created in this position in the tree.
3178 rb_bug("Unexpected node type in pattern matching expression: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
3179 break;
3180 }
3181
3182 return COMPILE_OK;
3183}
3184
3185#undef PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE
3186#undef PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING
3187#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P
3188#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE
3189#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY
3190
3191// Generate a scope node from the given node.
3192void
3193pm_scope_node_init(const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_t *previous)
3194{
3195 // This is very important, otherwise the scope node could be seen as having
3196 // certain flags set that _should not_ be set.
3197 memset(scope, 0, sizeof(pm_scope_node_t));
3198
3199 scope->base.type = PM_SCOPE_NODE;
3200 scope->base.location.start = node->location.start;
3201 scope->base.location.end = node->location.end;
3202
3203 scope->previous = previous;
3204 scope->ast_node = (pm_node_t *) node;
3205
3206 if (previous) {
3207 scope->parser = previous->parser;
3208 scope->encoding = previous->encoding;
3209 scope->filepath_encoding = previous->filepath_encoding;
3210 scope->constants = previous->constants;
3211 scope->coverage_enabled = previous->coverage_enabled;
3212 scope->script_lines = previous->script_lines;
3213 }
3214
3215 switch (PM_NODE_TYPE(node)) {
3216 case PM_BLOCK_NODE: {
3217 const pm_block_node_t *cast = (const pm_block_node_t *) node;
3218 scope->body = cast->body;
3219 scope->locals = cast->locals;
3220 scope->parameters = cast->parameters;
3221 break;
3222 }
3223 case PM_CLASS_NODE: {
3224 const pm_class_node_t *cast = (const pm_class_node_t *) node;
3225 scope->body = cast->body;
3226 scope->locals = cast->locals;
3227 break;
3228 }
3229 case PM_DEF_NODE: {
3230 const pm_def_node_t *cast = (const pm_def_node_t *) node;
3231 scope->parameters = (pm_node_t *) cast->parameters;
3232 scope->body = cast->body;
3233 scope->locals = cast->locals;
3234 break;
3235 }
3236 case PM_ENSURE_NODE: {
3237 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
3238 scope->body = (pm_node_t *) node;
3239
3240 if (cast->statements != NULL) {
3241 scope->base.location.start = cast->statements->base.location.start;
3242 scope->base.location.end = cast->statements->base.location.end;
3243 }
3244
3245 break;
3246 }
3247 case PM_FOR_NODE: {
3248 const pm_for_node_t *cast = (const pm_for_node_t *) node;
3249 scope->body = (pm_node_t *) cast->statements;
3250 break;
3251 }
3252 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
3253 RUBY_ASSERT(node->flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE);
3254 scope->body = (pm_node_t *) node;
3255 break;
3256 }
3257 case PM_LAMBDA_NODE: {
3258 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
3259 scope->parameters = cast->parameters;
3260 scope->body = cast->body;
3261 scope->locals = cast->locals;
3262
3263 if (cast->parameters != NULL) {
3264 scope->base.location.start = cast->parameters->location.start;
3265 }
3266 else {
3267 scope->base.location.start = cast->operator_loc.end;
3268 }
3269 break;
3270 }
3271 case PM_MODULE_NODE: {
3272 const pm_module_node_t *cast = (const pm_module_node_t *) node;
3273 scope->body = cast->body;
3274 scope->locals = cast->locals;
3275 break;
3276 }
3277 case PM_POST_EXECUTION_NODE: {
3278 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
3279 scope->body = (pm_node_t *) cast->statements;
3280 break;
3281 }
3282 case PM_PROGRAM_NODE: {
3283 const pm_program_node_t *cast = (const pm_program_node_t *) node;
3284 scope->body = (pm_node_t *) cast->statements;
3285 scope->locals = cast->locals;
3286 break;
3287 }
3288 case PM_RESCUE_NODE: {
3289 const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
3290 scope->body = (pm_node_t *) cast->statements;
3291 break;
3292 }
3293 case PM_RESCUE_MODIFIER_NODE: {
3294 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
3295 scope->body = (pm_node_t *) cast->rescue_expression;
3296 break;
3297 }
3298 case PM_SINGLETON_CLASS_NODE: {
3299 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
3300 scope->body = cast->body;
3301 scope->locals = cast->locals;
3302 break;
3303 }
3304 case PM_STATEMENTS_NODE: {
3305 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
3306 scope->body = (pm_node_t *) cast;
3307 break;
3308 }
3309 default:
3310 rb_bug("unreachable");
3311 break;
3312 }
3313}
3314
3315void
3316pm_scope_node_destroy(pm_scope_node_t *scope_node)
3317{
3318 if (scope_node->index_lookup_table) {
3319 st_free_table(scope_node->index_lookup_table);
3320 }
3321}
3322
3334static void
3335pm_compile_retry_end_label(rb_iseq_t *iseq, LINK_ANCHOR *const ret, LABEL *retry_end_l)
3336{
3337 INSN *iobj;
3338 LINK_ELEMENT *last_elem = LAST_ELEMENT(ret);
3339 iobj = IS_INSN(last_elem) ? (INSN*) last_elem : (INSN*) get_prev_insn((INSN*) last_elem);
3340 while (!IS_INSN_ID(iobj, send) && !IS_INSN_ID(iobj, invokesuper) && !IS_INSN_ID(iobj, sendforward) && !IS_INSN_ID(iobj, invokesuperforward)) {
3341 iobj = (INSN*) get_prev_insn(iobj);
3342 }
3343 ELEM_INSERT_NEXT(&iobj->link, (LINK_ELEMENT*) retry_end_l);
3344
3345 // LINK_ANCHOR has a pointer to the last element, but
3346 // ELEM_INSERT_NEXT does not update it even if we add an insn to the
3347 // last of LINK_ANCHOR. So this updates it manually.
3348 if (&iobj->link == LAST_ELEMENT(ret)) {
3349 ret->last = (LINK_ELEMENT*) retry_end_l;
3350 }
3351}
3352
3353static const char *
3354pm_iseq_builtin_function_name(const pm_scope_node_t *scope_node, const pm_node_t *receiver, ID method_id)
3355{
3356 const char *name = rb_id2name(method_id);
3357 static const char prefix[] = "__builtin_";
3358 const size_t prefix_len = sizeof(prefix) - 1;
3359
3360 if (receiver == NULL) {
3361 if (UNLIKELY(strncmp(prefix, name, prefix_len) == 0)) {
3362 // __builtin_foo
3363 return &name[prefix_len];
3364 }
3365 }
3366 else if (PM_NODE_TYPE_P(receiver, PM_CALL_NODE)) {
3367 if (PM_NODE_FLAG_P(receiver, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3368 const pm_call_node_t *cast = (const pm_call_node_t *) receiver;
3369 if (pm_constant_id_lookup(scope_node, cast->name) == rb_intern_const("__builtin")) {
3370 // __builtin.foo
3371 return name;
3372 }
3373 }
3374 }
3375 else if (PM_NODE_TYPE_P(receiver, PM_CONSTANT_READ_NODE)) {
3376 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) receiver;
3377 if (pm_constant_id_lookup(scope_node, cast->name) == rb_intern_const("Primitive")) {
3378 // Primitive.foo
3379 return name;
3380 }
3381 }
3382
3383 return NULL;
3384}
3385
3386// Compile Primitive.attr! :leaf, ...
3387static int
3388pm_compile_builtin_attr(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_arguments_node_t *arguments, const pm_node_location_t *node_location)
3389{
3390 if (arguments == NULL) {
3391 COMPILE_ERROR(iseq, node_location->line, "attr!: no argument");
3392 return COMPILE_NG;
3393 }
3394
3395 const pm_node_t *argument;
3396 PM_NODE_LIST_FOREACH(&arguments->arguments, index, argument) {
3397 if (!PM_NODE_TYPE_P(argument, PM_SYMBOL_NODE)) {
3398 COMPILE_ERROR(iseq, node_location->line, "non symbol argument to attr!: %s", pm_node_type_to_str(PM_NODE_TYPE(argument)));
3399 return COMPILE_NG;
3400 }
3401
3402 VALUE symbol = pm_static_literal_value(iseq, argument, scope_node);
3403 VALUE string = rb_sym2str(symbol);
3404
3405 if (strcmp(RSTRING_PTR(string), "leaf") == 0) {
3406 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_LEAF;
3407 }
3408 else if (strcmp(RSTRING_PTR(string), "inline_block") == 0) {
3409 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_INLINE_BLOCK;
3410 }
3411 else if (strcmp(RSTRING_PTR(string), "use_block") == 0) {
3412 iseq_set_use_block(iseq);
3413 }
3414 else if (strcmp(RSTRING_PTR(string), "c_trace") == 0) {
3415 // Let the iseq act like a C method in backtraces
3416 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_C_TRACE;
3417 }
3418 else {
3419 COMPILE_ERROR(iseq, node_location->line, "unknown argument to attr!: %s", RSTRING_PTR(string));
3420 return COMPILE_NG;
3421 }
3422 }
3423
3424 return COMPILE_OK;
3425}
3426
3427static int
3428pm_compile_builtin_arg(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_scope_node_t *scope_node, const pm_arguments_node_t *arguments, const pm_node_location_t *node_location, int popped)
3429{
3430 if (arguments == NULL) {
3431 COMPILE_ERROR(iseq, node_location->line, "arg!: no argument");
3432 return COMPILE_NG;
3433 }
3434
3435 if (arguments->arguments.size != 1) {
3436 COMPILE_ERROR(iseq, node_location->line, "arg!: too many argument");
3437 return COMPILE_NG;
3438 }
3439
3440 const pm_node_t *argument = arguments->arguments.nodes[0];
3441 if (!PM_NODE_TYPE_P(argument, PM_SYMBOL_NODE)) {
3442 COMPILE_ERROR(iseq, node_location->line, "non symbol argument to arg!: %s", pm_node_type_to_str(PM_NODE_TYPE(argument)));
3443 return COMPILE_NG;
3444 }
3445
3446 if (!popped) {
3447 ID name = parse_string_symbol(scope_node, ((const pm_symbol_node_t *) argument));
3448 int index = ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->local_table_size - get_local_var_idx(iseq, name);
3449
3450 debugs("id: %s idx: %d\n", rb_id2name(name), index);
3451 PUSH_GETLOCAL(ret, *node_location, index, get_lvar_level(iseq));
3452 }
3453
3454 return COMPILE_OK;
3455}
3456
3457static int
3458pm_compile_builtin_mandatory_only_method(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_call_node_t *call_node, const pm_node_location_t *node_location)
3459{
3460 const pm_node_t *ast_node = scope_node->ast_node;
3461 if (!PM_NODE_TYPE_P(ast_node, PM_DEF_NODE)) {
3462 rb_bug("mandatory_only?: not in method definition");
3463 return COMPILE_NG;
3464 }
3465
3466 const pm_def_node_t *def_node = (const pm_def_node_t *) ast_node;
3467 const pm_parameters_node_t *parameters_node = def_node->parameters;
3468 if (parameters_node == NULL) {
3469 rb_bug("mandatory_only?: in method definition with no parameters");
3470 return COMPILE_NG;
3471 }
3472
3473 const pm_node_t *body_node = def_node->body;
3474 if (body_node == NULL || !PM_NODE_TYPE_P(body_node, PM_STATEMENTS_NODE) || (((const pm_statements_node_t *) body_node)->body.size != 1) || !PM_NODE_TYPE_P(((const pm_statements_node_t *) body_node)->body.nodes[0], PM_IF_NODE)) {
3475 rb_bug("mandatory_only?: not in method definition with plain statements");
3476 return COMPILE_NG;
3477 }
3478
3479 const pm_if_node_t *if_node = (const pm_if_node_t *) ((const pm_statements_node_t *) body_node)->body.nodes[0];
3480 if (if_node->predicate != ((const pm_node_t *) call_node)) {
3481 rb_bug("mandatory_only?: can't find mandatory node");
3482 return COMPILE_NG;
3483 }
3484
3485 pm_parameters_node_t parameters = {
3486 .base = parameters_node->base,
3487 .requireds = parameters_node->requireds
3488 };
3489
3490 const pm_def_node_t def = {
3491 .base = def_node->base,
3492 .name = def_node->name,
3493 .receiver = def_node->receiver,
3494 .parameters = &parameters,
3495 .body = (pm_node_t *) if_node->statements,
3496 .locals = {
3497 .ids = def_node->locals.ids,
3498 .size = parameters_node->requireds.size,
3499 .capacity = def_node->locals.capacity
3500 }
3501 };
3502
3503 pm_scope_node_t next_scope_node;
3504 pm_scope_node_init(&def.base, &next_scope_node, scope_node);
3505
3506 int error_state;
3507 const rb_iseq_t *mandatory_only_iseq = pm_iseq_new_with_opt(
3508 &next_scope_node,
3509 rb_iseq_base_label(iseq),
3510 rb_iseq_path(iseq),
3511 rb_iseq_realpath(iseq),
3512 node_location->line,
3513 NULL,
3514 0,
3515 ISEQ_TYPE_METHOD,
3516 ISEQ_COMPILE_DATA(iseq)->option,
3517 &error_state
3518 );
3519 RB_OBJ_WRITE(iseq, &ISEQ_BODY(iseq)->mandatory_only_iseq, (VALUE)mandatory_only_iseq);
3520
3521 if (error_state) {
3522 RUBY_ASSERT(ISEQ_BODY(iseq)->mandatory_only_iseq == NULL);
3523 rb_jump_tag(error_state);
3524 }
3525
3526 pm_scope_node_destroy(&next_scope_node);
3527 return COMPILE_OK;
3528}
3529
3530static int
3531pm_compile_builtin_function_call(rb_iseq_t *iseq, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node, const pm_call_node_t *call_node, const pm_node_location_t *node_location, int popped, const rb_iseq_t *parent_block, const char *builtin_func)
3532{
3533 const pm_arguments_node_t *arguments = call_node->arguments;
3534
3535 if (parent_block != NULL) {
3536 COMPILE_ERROR(iseq, node_location->line, "should not call builtins here.");
3537 return COMPILE_NG;
3538 }
3539
3540#define BUILTIN_INLINE_PREFIX "_bi"
3541 char inline_func[sizeof(BUILTIN_INLINE_PREFIX) + DECIMAL_SIZE_OF(int)];
3542 bool cconst = false;
3543retry:;
3544 const struct rb_builtin_function *bf = iseq_builtin_function_lookup(iseq, builtin_func);
3545
3546 if (bf == NULL) {
3547 if (strcmp("cstmt!", builtin_func) == 0 || strcmp("cexpr!", builtin_func) == 0) {
3548 // ok
3549 }
3550 else if (strcmp("cconst!", builtin_func) == 0) {
3551 cconst = true;
3552 }
3553 else if (strcmp("cinit!", builtin_func) == 0) {
3554 // ignore
3555 return COMPILE_OK;
3556 }
3557 else if (strcmp("attr!", builtin_func) == 0) {
3558 return pm_compile_builtin_attr(iseq, scope_node, arguments, node_location);
3559 }
3560 else if (strcmp("arg!", builtin_func) == 0) {
3561 return pm_compile_builtin_arg(iseq, ret, scope_node, arguments, node_location, popped);
3562 }
3563 else if (strcmp("mandatory_only?", builtin_func) == 0) {
3564 if (popped) {
3565 rb_bug("mandatory_only? should be in if condition");
3566 }
3567 else if (!LIST_INSN_SIZE_ZERO(ret)) {
3568 rb_bug("mandatory_only? should be put on top");
3569 }
3570
3571 PUSH_INSN1(ret, *node_location, putobject, Qfalse);
3572 return pm_compile_builtin_mandatory_only_method(iseq, scope_node, call_node, node_location);
3573 }
3574 else if (1) {
3575 rb_bug("can't find builtin function:%s", builtin_func);
3576 }
3577 else {
3578 COMPILE_ERROR(iseq, node_location->line, "can't find builtin function:%s", builtin_func);
3579 return COMPILE_NG;
3580 }
3581
3582 int inline_index = node_location->line;
3583 snprintf(inline_func, sizeof(inline_func), BUILTIN_INLINE_PREFIX "%d", inline_index);
3584 builtin_func = inline_func;
3585 arguments = NULL;
3586 goto retry;
3587 }
3588
3589 if (cconst) {
3590 typedef VALUE(*builtin_func0)(void *, VALUE);
3591 VALUE const_val = (*(builtin_func0)(uintptr_t)bf->func_ptr)(NULL, Qnil);
3592 PUSH_INSN1(ret, *node_location, putobject, const_val);
3593 return COMPILE_OK;
3594 }
3595
3596 // fprintf(stderr, "func_name:%s -> %p\n", builtin_func, bf->func_ptr);
3597
3598 DECL_ANCHOR(args_seq);
3599
3600 int flags = 0;
3601 struct rb_callinfo_kwarg *keywords = NULL;
3602 int argc = pm_setup_args(arguments, call_node->block, &flags, &keywords, iseq, args_seq, scope_node, node_location);
3603
3604 if (argc != bf->argc) {
3605 COMPILE_ERROR(iseq, node_location->line, "argc is not match for builtin function:%s (expect %d but %d)", builtin_func, bf->argc, argc);
3606 return COMPILE_NG;
3607 }
3608
3609 unsigned int start_index;
3610 if (delegate_call_p(iseq, argc, args_seq, &start_index)) {
3611 PUSH_INSN2(ret, *node_location, opt_invokebuiltin_delegate, bf, INT2FIX(start_index));
3612 }
3613 else {
3614 PUSH_SEQ(ret, args_seq);
3615 PUSH_INSN1(ret, *node_location, invokebuiltin, bf);
3616 }
3617
3618 if (popped) PUSH_INSN(ret, *node_location, pop);
3619 return COMPILE_OK;
3620}
3621
3625static void
3626pm_compile_call(rb_iseq_t *iseq, const pm_call_node_t *call_node, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node, ID method_id, LABEL *start)
3627{
3628 const pm_location_t *message_loc = &call_node->message_loc;
3629 if (message_loc->start == NULL) message_loc = &call_node->base.location;
3630
3631 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, message_loc, call_node->base.node_id);
3632 LABEL *else_label = NEW_LABEL(location.line);
3633 LABEL *end_label = NEW_LABEL(location.line);
3634 LABEL *retry_end_l = NEW_LABEL(location.line);
3635
3636 VALUE branches = Qfalse;
3637 rb_code_location_t code_location = { 0 };
3638 int node_id = location.node_id;
3639
3640 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3641 if (PM_BRANCH_COVERAGE_P(iseq)) {
3642 const uint8_t *cursors[3] = {
3643 call_node->closing_loc.end,
3644 call_node->arguments == NULL ? NULL : call_node->arguments->base.location.end,
3645 call_node->message_loc.end
3646 };
3647
3648 const uint8_t *end_cursor = cursors[0];
3649 end_cursor = (end_cursor == NULL || cursors[1] == NULL) ? cursors[1] : (end_cursor > cursors[1] ? end_cursor : cursors[1]);
3650 end_cursor = (end_cursor == NULL || cursors[2] == NULL) ? cursors[2] : (end_cursor > cursors[2] ? end_cursor : cursors[2]);
3651 if (!end_cursor) end_cursor = call_node->closing_loc.end;
3652
3653 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, call_node);
3654 const pm_line_column_t end_location = pm_newline_list_line_column(&scope_node->parser->newline_list, end_cursor, scope_node->parser->start_line);
3655
3656 code_location = (rb_code_location_t) {
3657 .beg_pos = { .lineno = start_location.line, .column = start_location.column },
3658 .end_pos = { .lineno = end_location.line, .column = end_location.column }
3659 };
3660
3661 branches = decl_branch_base(iseq, PTR2NUM(call_node), &code_location, "&.");
3662 }
3663
3664 PUSH_INSN(ret, location, dup);
3665 PUSH_INSNL(ret, location, branchnil, else_label);
3666
3667 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 0, "then", branches);
3668 }
3669
3670 int flags = 0;
3671 struct rb_callinfo_kwarg *kw_arg = NULL;
3672
3673 int orig_argc = pm_setup_args(call_node->arguments, call_node->block, &flags, &kw_arg, iseq, ret, scope_node, &location);
3674 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
3675 const rb_iseq_t *block_iseq = NULL;
3676
3677 if (call_node->block != NULL && PM_NODE_TYPE_P(call_node->block, PM_BLOCK_NODE)) {
3678 // Scope associated with the block
3679 pm_scope_node_t next_scope_node;
3680 pm_scope_node_init(call_node->block, &next_scope_node, scope_node);
3681
3682 block_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, pm_node_line_number(scope_node->parser, call_node->block));
3683 pm_scope_node_destroy(&next_scope_node);
3684 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
3685 }
3686 else {
3687 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3688 flags |= VM_CALL_VCALL;
3689 }
3690
3691 if (!flags) {
3692 flags |= VM_CALL_ARGS_SIMPLE;
3693 }
3694 }
3695
3696 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3697 flags |= VM_CALL_FCALL;
3698 }
3699
3700 if (!popped && PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3701 if (flags & VM_CALL_ARGS_BLOCKARG) {
3702 PUSH_INSN1(ret, location, topn, INT2FIX(1));
3703 if (flags & VM_CALL_ARGS_SPLAT) {
3704 PUSH_INSN1(ret, location, putobject, INT2FIX(-1));
3705 PUSH_SEND_WITH_FLAG(ret, location, idAREF, INT2FIX(1), INT2FIX(0));
3706 }
3707 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 3));
3708 PUSH_INSN(ret, location, pop);
3709 }
3710 else if (flags & VM_CALL_ARGS_SPLAT) {
3711 PUSH_INSN(ret, location, dup);
3712 PUSH_INSN1(ret, location, putobject, INT2FIX(-1));
3713 PUSH_SEND_WITH_FLAG(ret, location, idAREF, INT2FIX(1), INT2FIX(0));
3714 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 2));
3715 PUSH_INSN(ret, location, pop);
3716 }
3717 else {
3718 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 1));
3719 }
3720 }
3721
3722 if ((flags & VM_CALL_KW_SPLAT) && (flags & VM_CALL_ARGS_BLOCKARG) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
3723 PUSH_INSN(ret, location, splatkw);
3724 }
3725
3726 PUSH_SEND_R(ret, location, method_id, INT2FIX(orig_argc), block_iseq, INT2FIX(flags), kw_arg);
3727
3728 if (block_iseq && ISEQ_BODY(block_iseq)->catch_table) {
3729 pm_compile_retry_end_label(iseq, ret, retry_end_l);
3730 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, start, retry_end_l, block_iseq, retry_end_l);
3731 }
3732
3733 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3734 PUSH_INSNL(ret, location, jump, end_label);
3735 PUSH_LABEL(ret, else_label);
3736 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 1, "else", branches);
3737 PUSH_LABEL(ret, end_label);
3738 }
3739
3740 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) && !popped) {
3741 PUSH_INSN(ret, location, pop);
3742 }
3743
3744 if (popped) PUSH_INSN(ret, location, pop);
3745 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
3746}
3747
3752static inline VALUE
3753pm_compile_back_reference_ref(const pm_back_reference_read_node_t *node)
3754{
3755 const char *type = (const char *) (node->base.location.start + 1);
3756
3757 // Since a back reference is `$<char>`, Ruby represents the ID as an
3758 // rb_intern on the value after the `$`.
3759 return INT2FIX(rb_intern2(type, 1)) << 1 | 1;
3760}
3761
3766static inline VALUE
3767pm_compile_numbered_reference_ref(const pm_numbered_reference_read_node_t *node)
3768{
3769 return INT2FIX(node->number << 1);
3770}
3771
3772static void
3773pm_compile_defined_expr0(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node, bool in_condition, LABEL **lfinish, bool explicit_receiver)
3774{
3775#define PUSH_VAL(type) (in_condition ? Qtrue : rb_iseq_defined_string(type))
3776
3777 // in_condition is the same as compile.c's needstr
3778 enum defined_type dtype = DEFINED_NOT_DEFINED;
3779 const pm_node_location_t location = *node_location;
3780
3781 switch (PM_NODE_TYPE(node)) {
3782/* DEFINED_NIL ****************************************************************/
3783 case PM_NIL_NODE:
3784 // defined?(nil)
3785 // ^^^
3786 dtype = DEFINED_NIL;
3787 break;
3788/* DEFINED_IVAR ***************************************************************/
3789 case PM_INSTANCE_VARIABLE_READ_NODE: {
3790 // defined?(@a)
3791 // ^^
3792 const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
3793 ID name = pm_constant_id_lookup(scope_node, cast->name);
3794
3795 PUSH_INSN3(ret, location, definedivar, ID2SYM(name), get_ivar_ic_value(iseq, name), PUSH_VAL(DEFINED_IVAR));
3796
3797 return;
3798 }
3799/* DEFINED_LVAR ***************************************************************/
3800 case PM_LOCAL_VARIABLE_READ_NODE:
3801 // a = 1; defined?(a)
3802 // ^
3803 case PM_IT_LOCAL_VARIABLE_READ_NODE:
3804 // 1.then { defined?(it) }
3805 // ^^
3806 dtype = DEFINED_LVAR;
3807 break;
3808/* DEFINED_GVAR ***************************************************************/
3809 case PM_GLOBAL_VARIABLE_READ_NODE: {
3810 // defined?($a)
3811 // ^^
3812 const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
3813 ID name = pm_constant_id_lookup(scope_node, cast->name);
3814
3815 PUSH_INSN(ret, location, putnil);
3816 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_GVAR), ID2SYM(name), PUSH_VAL(DEFINED_GVAR));
3817
3818 return;
3819 }
3820/* DEFINED_CVAR ***************************************************************/
3821 case PM_CLASS_VARIABLE_READ_NODE: {
3822 // defined?(@@a)
3823 // ^^^
3824 const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
3825 ID name = pm_constant_id_lookup(scope_node, cast->name);
3826
3827 PUSH_INSN(ret, location, putnil);
3828 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CVAR), ID2SYM(name), PUSH_VAL(DEFINED_CVAR));
3829
3830 return;
3831 }
3832/* DEFINED_CONST **************************************************************/
3833 case PM_CONSTANT_READ_NODE: {
3834 // defined?(A)
3835 // ^
3836 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
3837 ID name = pm_constant_id_lookup(scope_node, cast->name);
3838
3839 PUSH_INSN(ret, location, putnil);
3840 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST), ID2SYM(name), PUSH_VAL(DEFINED_CONST));
3841
3842 return;
3843 }
3844/* DEFINED_YIELD **************************************************************/
3845 case PM_YIELD_NODE:
3846 // defined?(yield)
3847 // ^^^^^
3848 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
3849
3850 PUSH_INSN(ret, location, putnil);
3851 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_YIELD), 0, PUSH_VAL(DEFINED_YIELD));
3852
3853 return;
3854/* DEFINED_ZSUPER *************************************************************/
3855 case PM_SUPER_NODE: {
3856 // defined?(super 1, 2)
3857 // ^^^^^^^^^^
3858 const pm_super_node_t *cast = (const pm_super_node_t *) node;
3859
3860 if (cast->block != NULL && !PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE)) {
3861 dtype = DEFINED_EXPR;
3862 break;
3863 }
3864
3865 PUSH_INSN(ret, location, putnil);
3866 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3867 return;
3868 }
3869 case PM_FORWARDING_SUPER_NODE: {
3870 // defined?(super)
3871 // ^^^^^
3872 const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
3873
3874 if (cast->block != NULL) {
3875 dtype = DEFINED_EXPR;
3876 break;
3877 }
3878
3879 PUSH_INSN(ret, location, putnil);
3880 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3881 return;
3882 }
3883/* DEFINED_SELF ***************************************************************/
3884 case PM_SELF_NODE:
3885 // defined?(self)
3886 // ^^^^
3887 dtype = DEFINED_SELF;
3888 break;
3889/* DEFINED_TRUE ***************************************************************/
3890 case PM_TRUE_NODE:
3891 // defined?(true)
3892 // ^^^^
3893 dtype = DEFINED_TRUE;
3894 break;
3895/* DEFINED_FALSE **************************************************************/
3896 case PM_FALSE_NODE:
3897 // defined?(false)
3898 // ^^^^^
3899 dtype = DEFINED_FALSE;
3900 break;
3901/* DEFINED_ASGN ***************************************************************/
3902 case PM_CALL_AND_WRITE_NODE:
3903 // defined?(a.a &&= 1)
3904 // ^^^^^^^^^
3905 case PM_CALL_OPERATOR_WRITE_NODE:
3906 // defined?(a.a += 1)
3907 // ^^^^^^^^
3908 case PM_CALL_OR_WRITE_NODE:
3909 // defined?(a.a ||= 1)
3910 // ^^^^^^^^^
3911 case PM_CLASS_VARIABLE_AND_WRITE_NODE:
3912 // defined?(@@a &&= 1)
3913 // ^^^^^^^^^
3914 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
3915 // defined?(@@a += 1)
3916 // ^^^^^^^^
3917 case PM_CLASS_VARIABLE_OR_WRITE_NODE:
3918 // defined?(@@a ||= 1)
3919 // ^^^^^^^^^
3920 case PM_CLASS_VARIABLE_WRITE_NODE:
3921 // defined?(@@a = 1)
3922 // ^^^^^^^
3923 case PM_CONSTANT_AND_WRITE_NODE:
3924 // defined?(A &&= 1)
3925 // ^^^^^^^
3926 case PM_CONSTANT_OPERATOR_WRITE_NODE:
3927 // defined?(A += 1)
3928 // ^^^^^^
3929 case PM_CONSTANT_OR_WRITE_NODE:
3930 // defined?(A ||= 1)
3931 // ^^^^^^^
3932 case PM_CONSTANT_PATH_AND_WRITE_NODE:
3933 // defined?(A::A &&= 1)
3934 // ^^^^^^^^^^
3935 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE:
3936 // defined?(A::A += 1)
3937 // ^^^^^^^^^
3938 case PM_CONSTANT_PATH_OR_WRITE_NODE:
3939 // defined?(A::A ||= 1)
3940 // ^^^^^^^^^^
3941 case PM_CONSTANT_PATH_WRITE_NODE:
3942 // defined?(A::A = 1)
3943 // ^^^^^^^^
3944 case PM_CONSTANT_WRITE_NODE:
3945 // defined?(A = 1)
3946 // ^^^^^
3947 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE:
3948 // defined?($a &&= 1)
3949 // ^^^^^^^^
3950 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
3951 // defined?($a += 1)
3952 // ^^^^^^^
3953 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE:
3954 // defined?($a ||= 1)
3955 // ^^^^^^^^
3956 case PM_GLOBAL_VARIABLE_WRITE_NODE:
3957 // defined?($a = 1)
3958 // ^^^^^^
3959 case PM_INDEX_AND_WRITE_NODE:
3960 // defined?(a[1] &&= 1)
3961 // ^^^^^^^^^^
3962 case PM_INDEX_OPERATOR_WRITE_NODE:
3963 // defined?(a[1] += 1)
3964 // ^^^^^^^^^
3965 case PM_INDEX_OR_WRITE_NODE:
3966 // defined?(a[1] ||= 1)
3967 // ^^^^^^^^^^
3968 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE:
3969 // defined?(@a &&= 1)
3970 // ^^^^^^^^
3971 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
3972 // defined?(@a += 1)
3973 // ^^^^^^^
3974 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE:
3975 // defined?(@a ||= 1)
3976 // ^^^^^^^^
3977 case PM_INSTANCE_VARIABLE_WRITE_NODE:
3978 // defined?(@a = 1)
3979 // ^^^^^^
3980 case PM_LOCAL_VARIABLE_AND_WRITE_NODE:
3981 // defined?(a &&= 1)
3982 // ^^^^^^^
3983 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
3984 // defined?(a += 1)
3985 // ^^^^^^
3986 case PM_LOCAL_VARIABLE_OR_WRITE_NODE:
3987 // defined?(a ||= 1)
3988 // ^^^^^^^
3989 case PM_LOCAL_VARIABLE_WRITE_NODE:
3990 // defined?(a = 1)
3991 // ^^^^^
3992 case PM_MULTI_WRITE_NODE:
3993 // defined?((a, = 1))
3994 // ^^^^^^
3995 dtype = DEFINED_ASGN;
3996 break;
3997/* DEFINED_EXPR ***************************************************************/
3998 case PM_ALIAS_GLOBAL_VARIABLE_NODE:
3999 // defined?((alias $a $b))
4000 // ^^^^^^^^^^^
4001 case PM_ALIAS_METHOD_NODE:
4002 // defined?((alias a b))
4003 // ^^^^^^^^^
4004 case PM_AND_NODE:
4005 // defined?(a and b)
4006 // ^^^^^^^
4007 case PM_BREAK_NODE:
4008 // defined?(break 1)
4009 // ^^^^^^^
4010 case PM_CASE_MATCH_NODE:
4011 // defined?(case 1; in 1; end)
4012 // ^^^^^^^^^^^^^^^^^
4013 case PM_CASE_NODE:
4014 // defined?(case 1; when 1; end)
4015 // ^^^^^^^^^^^^^^^^^^^
4016 case PM_CLASS_NODE:
4017 // defined?(class Foo; end)
4018 // ^^^^^^^^^^^^^^
4019 case PM_DEF_NODE:
4020 // defined?(def a() end)
4021 // ^^^^^^^^^^^
4022 case PM_DEFINED_NODE:
4023 // defined?(defined?(a))
4024 // ^^^^^^^^^^^
4025 case PM_FLIP_FLOP_NODE:
4026 // defined?(not (a .. b))
4027 // ^^^^^^
4028 case PM_FLOAT_NODE:
4029 // defined?(1.0)
4030 // ^^^
4031 case PM_FOR_NODE:
4032 // defined?(for a in 1 do end)
4033 // ^^^^^^^^^^^^^^^^^
4034 case PM_IF_NODE:
4035 // defined?(if a then end)
4036 // ^^^^^^^^^^^^^
4037 case PM_IMAGINARY_NODE:
4038 // defined?(1i)
4039 // ^^
4040 case PM_INTEGER_NODE:
4041 // defined?(1)
4042 // ^
4043 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE:
4044 // defined?(not /#{1}/)
4045 // ^^^^^^
4046 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
4047 // defined?(/#{1}/)
4048 // ^^^^^^
4049 case PM_INTERPOLATED_STRING_NODE:
4050 // defined?("#{1}")
4051 // ^^^^^^
4052 case PM_INTERPOLATED_SYMBOL_NODE:
4053 // defined?(:"#{1}")
4054 // ^^^^^^^
4055 case PM_INTERPOLATED_X_STRING_NODE:
4056 // defined?(`#{1}`)
4057 // ^^^^^^
4058 case PM_LAMBDA_NODE:
4059 // defined?(-> {})
4060 // ^^^^^
4061 case PM_MATCH_LAST_LINE_NODE:
4062 // defined?(not //)
4063 // ^^^^^^
4064 case PM_MATCH_PREDICATE_NODE:
4065 // defined?(1 in 1)
4066 // ^^^^^^
4067 case PM_MATCH_REQUIRED_NODE:
4068 // defined?(1 => 1)
4069 // ^^^^^^
4070 case PM_MATCH_WRITE_NODE:
4071 // defined?(/(?<a>)/ =~ "")
4072 // ^^^^^^^^^^^^^^
4073 case PM_MODULE_NODE:
4074 // defined?(module A end)
4075 // ^^^^^^^^^^^^
4076 case PM_NEXT_NODE:
4077 // defined?(next 1)
4078 // ^^^^^^
4079 case PM_OR_NODE:
4080 // defined?(a or b)
4081 // ^^^^^^
4082 case PM_POST_EXECUTION_NODE:
4083 // defined?((END {}))
4084 // ^^^^^^^^
4085 case PM_RANGE_NODE:
4086 // defined?(1..1)
4087 // ^^^^
4088 case PM_RATIONAL_NODE:
4089 // defined?(1r)
4090 // ^^
4091 case PM_REDO_NODE:
4092 // defined?(redo)
4093 // ^^^^
4094 case PM_REGULAR_EXPRESSION_NODE:
4095 // defined?(//)
4096 // ^^
4097 case PM_RESCUE_MODIFIER_NODE:
4098 // defined?(a rescue b)
4099 // ^^^^^^^^^^
4100 case PM_RETRY_NODE:
4101 // defined?(retry)
4102 // ^^^^^
4103 case PM_RETURN_NODE:
4104 // defined?(return)
4105 // ^^^^^^
4106 case PM_SINGLETON_CLASS_NODE:
4107 // defined?(class << self; end)
4108 // ^^^^^^^^^^^^^^^^^^
4109 case PM_SOURCE_ENCODING_NODE:
4110 // defined?(__ENCODING__)
4111 // ^^^^^^^^^^^^
4112 case PM_SOURCE_FILE_NODE:
4113 // defined?(__FILE__)
4114 // ^^^^^^^^
4115 case PM_SOURCE_LINE_NODE:
4116 // defined?(__LINE__)
4117 // ^^^^^^^^
4118 case PM_STRING_NODE:
4119 // defined?("")
4120 // ^^
4121 case PM_SYMBOL_NODE:
4122 // defined?(:a)
4123 // ^^
4124 case PM_UNDEF_NODE:
4125 // defined?((undef a))
4126 // ^^^^^^^
4127 case PM_UNLESS_NODE:
4128 // defined?(unless a then end)
4129 // ^^^^^^^^^^^^^^^^^
4130 case PM_UNTIL_NODE:
4131 // defined?(until a do end)
4132 // ^^^^^^^^^^^^^^
4133 case PM_WHILE_NODE:
4134 // defined?(while a do end)
4135 // ^^^^^^^^^^^^^^
4136 case PM_X_STRING_NODE:
4137 // defined?(``)
4138 // ^^
4139 dtype = DEFINED_EXPR;
4140 break;
4141/* DEFINED_REF ****************************************************************/
4142 case PM_BACK_REFERENCE_READ_NODE: {
4143 // defined?($+)
4144 // ^^
4145 const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
4146 VALUE ref = pm_compile_back_reference_ref(cast);
4147
4148 PUSH_INSN(ret, location, putnil);
4149 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4150
4151 return;
4152 }
4153 case PM_NUMBERED_REFERENCE_READ_NODE: {
4154 // defined?($1)
4155 // ^^
4156 const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
4157 VALUE ref = pm_compile_numbered_reference_ref(cast);
4158
4159 PUSH_INSN(ret, location, putnil);
4160 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4161
4162 return;
4163 }
4164/* DEFINED_CONST_FROM *********************************************************/
4165 case PM_CONSTANT_PATH_NODE: {
4166 // defined?(A::A)
4167 // ^^^^
4168 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
4169 ID name = pm_constant_id_lookup(scope_node, cast->name);
4170
4171 if (cast->parent != NULL) {
4172 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4173 pm_compile_defined_expr0(iseq, cast->parent, node_location, ret, popped, scope_node, true, lfinish, false);
4174
4175 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4176 PM_COMPILE(cast->parent);
4177 }
4178 else {
4179 PUSH_INSN1(ret, location, putobject, rb_cObject);
4180 }
4181
4182 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST_FROM), ID2SYM(name), PUSH_VAL(DEFINED_CONST));
4183 return;
4184 }
4185/* Containers *****************************************************************/
4186 case PM_BEGIN_NODE: {
4187 // defined?(begin end)
4188 // ^^^^^^^^^
4189 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
4190
4191 if (cast->rescue_clause == NULL && cast->ensure_clause == NULL && cast->else_clause == NULL) {
4192 if (cast->statements == NULL) {
4193 // If we have empty statements, then we want to return "nil".
4194 dtype = DEFINED_NIL;
4195 }
4196 else if (cast->statements->body.size == 1) {
4197 // If we have a begin node that is wrapping a single statement
4198 // then we want to recurse down to that statement and compile
4199 // it.
4200 pm_compile_defined_expr0(iseq, cast->statements->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish, false);
4201 return;
4202 }
4203 else {
4204 // Otherwise, we have a begin wrapping multiple statements, in
4205 // which case this is defined as "expression".
4206 dtype = DEFINED_EXPR;
4207 }
4208 } else {
4209 // If we have any of the other clauses besides the main begin/end,
4210 // this is defined as "expression".
4211 dtype = DEFINED_EXPR;
4212 }
4213
4214 break;
4215 }
4216 case PM_PARENTHESES_NODE: {
4217 // defined?(())
4218 // ^^
4219 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
4220
4221 if (cast->body == NULL) {
4222 // If we have empty parentheses, then we want to return "nil".
4223 dtype = DEFINED_NIL;
4224 }
4225 else if (PM_NODE_TYPE_P(cast->body, PM_STATEMENTS_NODE) && ((const pm_statements_node_t *) cast->body)->body.size == 1) {
4226 // If we have a parentheses node that is wrapping a single statement
4227 // then we want to recurse down to that statement and compile it.
4228 pm_compile_defined_expr0(iseq, ((const pm_statements_node_t *) cast->body)->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4229 return;
4230 }
4231 else {
4232 // Otherwise, we have parentheses wrapping multiple statements, in
4233 // which case this is defined as "expression".
4234 dtype = DEFINED_EXPR;
4235 }
4236
4237 break;
4238 }
4239 case PM_ARRAY_NODE: {
4240 // defined?([])
4241 // ^^
4242 const pm_array_node_t *cast = (const pm_array_node_t *) node;
4243
4244 if (cast->elements.size > 0 && !lfinish[1]) {
4245 lfinish[1] = NEW_LABEL(location.line);
4246 }
4247
4248 for (size_t index = 0; index < cast->elements.size; index++) {
4249 pm_compile_defined_expr0(iseq, cast->elements.nodes[index], node_location, ret, popped, scope_node, true, lfinish, false);
4250 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4251 }
4252
4253 dtype = DEFINED_EXPR;
4254 break;
4255 }
4256 case PM_HASH_NODE:
4257 // defined?({ a: 1 })
4258 // ^^^^^^^^
4259 case PM_KEYWORD_HASH_NODE: {
4260 // defined?(a(a: 1))
4261 // ^^^^
4262 const pm_node_list_t *elements;
4263
4264 if (PM_NODE_TYPE_P(node, PM_HASH_NODE)) {
4265 elements = &((const pm_hash_node_t *) node)->elements;
4266 }
4267 else {
4268 elements = &((const pm_keyword_hash_node_t *) node)->elements;
4269 }
4270
4271 if (elements->size > 0 && !lfinish[1]) {
4272 lfinish[1] = NEW_LABEL(location.line);
4273 }
4274
4275 for (size_t index = 0; index < elements->size; index++) {
4276 pm_compile_defined_expr0(iseq, elements->nodes[index], node_location, ret, popped, scope_node, true, lfinish, false);
4277 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4278 }
4279
4280 dtype = DEFINED_EXPR;
4281 break;
4282 }
4283 case PM_ASSOC_NODE: {
4284 // defined?({ a: 1 })
4285 // ^^^^
4286 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
4287
4288 pm_compile_defined_expr0(iseq, cast->key, node_location, ret, popped, scope_node, true, lfinish, false);
4289 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4290 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, true, lfinish, false);
4291
4292 return;
4293 }
4294 case PM_ASSOC_SPLAT_NODE: {
4295 // defined?({ **a })
4296 // ^^^^
4297 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
4298
4299 if (cast->value == NULL) {
4300 dtype = DEFINED_EXPR;
4301 break;
4302 }
4303
4304 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, true, lfinish, false);
4305 return;
4306 }
4307 case PM_IMPLICIT_NODE: {
4308 // defined?({ a: })
4309 // ^^
4310 const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
4311 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4312 return;
4313 }
4314 case PM_CALL_NODE: {
4315#define BLOCK_P(cast) ((cast)->block != NULL && PM_NODE_TYPE_P((cast)->block, PM_BLOCK_NODE))
4316
4317 // defined?(a(1, 2, 3))
4318 // ^^^^^^^^^^
4319 const pm_call_node_t *cast = ((const pm_call_node_t *) node);
4320
4321 if (cast->block != NULL && PM_NODE_TYPE_P(cast->block, PM_BLOCK_NODE)) {
4322 dtype = DEFINED_EXPR;
4323 break;
4324 }
4325
4326 if (cast->receiver || cast->arguments || (cast->block && PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE))) {
4327 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4328 if (!lfinish[2]) lfinish[2] = NEW_LABEL(location.line);
4329 }
4330
4331 if (cast->arguments) {
4332 pm_compile_defined_expr0(iseq, (const pm_node_t *) cast->arguments, node_location, ret, popped, scope_node, true, lfinish, false);
4333 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4334 }
4335
4336 if (cast->block && PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE)) {
4337 pm_compile_defined_expr0(iseq, cast->block, node_location, ret, popped, scope_node, true, lfinish, false);
4338 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4339 }
4340
4341 if (cast->receiver) {
4342 if (PM_NODE_TYPE_P(cast->receiver, PM_CALL_NODE) && !BLOCK_P((const pm_call_node_t *) cast->receiver)) {
4343 // Special behavior here where we chain calls together. This is
4344 // the only path that sets explicit_receiver to true.
4345 pm_compile_defined_expr0(iseq, cast->receiver, node_location, ret, popped, scope_node, true, lfinish, true);
4346 PUSH_INSNL(ret, location, branchunless, lfinish[2]);
4347
4348 const pm_call_node_t *receiver = (const pm_call_node_t *) cast->receiver;
4349 ID method_id = pm_constant_id_lookup(scope_node, receiver->name);
4350
4351 pm_compile_call(iseq, receiver, ret, popped, scope_node, method_id, NULL);
4352 }
4353 else {
4354 pm_compile_defined_expr0(iseq, cast->receiver, node_location, ret, popped, scope_node, true, lfinish, false);
4355 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4356 PM_COMPILE(cast->receiver);
4357 }
4358
4359 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
4360
4361 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4362 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_METHOD), rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4363 }
4364 else {
4365 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
4366
4367 PUSH_INSN(ret, location, putself);
4368 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4369
4370 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_FUNC), rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4371 }
4372
4373 return;
4374 }
4375 case PM_ARGUMENTS_NODE: {
4376 // defined?(a(1, 2, 3))
4377 // ^^^^^^^
4378 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
4379
4380 for (size_t index = 0; index < cast->arguments.size; index++) {
4381 pm_compile_defined_expr0(iseq, cast->arguments.nodes[index], node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4382
4383 if (!lfinish[1]) {
4384 lfinish[1] = NEW_LABEL(location.line);
4385 }
4386 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4387 }
4388
4389 dtype = DEFINED_TRUE;
4390 break;
4391 }
4392 case PM_BLOCK_ARGUMENT_NODE:
4393 // defined?(a(&b))
4394 // ^^
4395 dtype = DEFINED_EXPR;
4396 break;
4397 case PM_FORWARDING_ARGUMENTS_NODE:
4398 // def a(...) = defined?(a(...))
4399 // ^^^
4400 dtype = DEFINED_EXPR;
4401 break;
4402 case PM_SPLAT_NODE: {
4403 // def a(*) = defined?(a(*))
4404 // ^
4405 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
4406
4407 if (cast->expression == NULL) {
4408 dtype = DEFINED_EXPR;
4409 break;
4410 }
4411
4412 pm_compile_defined_expr0(iseq, cast->expression, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4413
4414 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4415 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4416
4417 dtype = DEFINED_EXPR;
4418 break;
4419 }
4420 case PM_SHAREABLE_CONSTANT_NODE:
4421 // # shareable_constant_value: literal
4422 // defined?(A = 1)
4423 // ^^^^^
4424 pm_compile_defined_expr0(iseq, ((const pm_shareable_constant_node_t *) node)->write, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4425 return;
4426/* Unreachable (parameters) ***************************************************/
4427 case PM_BLOCK_LOCAL_VARIABLE_NODE:
4428 case PM_BLOCK_PARAMETER_NODE:
4429 case PM_BLOCK_PARAMETERS_NODE:
4430 case PM_FORWARDING_PARAMETER_NODE:
4431 case PM_IMPLICIT_REST_NODE:
4432 case PM_IT_PARAMETERS_NODE:
4433 case PM_PARAMETERS_NODE:
4434 case PM_KEYWORD_REST_PARAMETER_NODE:
4435 case PM_NO_KEYWORDS_PARAMETER_NODE:
4436 case PM_NUMBERED_PARAMETERS_NODE:
4437 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
4438 case PM_OPTIONAL_PARAMETER_NODE:
4439 case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
4440 case PM_REQUIRED_PARAMETER_NODE:
4441 case PM_REST_PARAMETER_NODE:
4442/* Unreachable (pattern matching) *********************************************/
4443 case PM_ALTERNATION_PATTERN_NODE:
4444 case PM_ARRAY_PATTERN_NODE:
4445 case PM_CAPTURE_PATTERN_NODE:
4446 case PM_FIND_PATTERN_NODE:
4447 case PM_HASH_PATTERN_NODE:
4448 case PM_PINNED_EXPRESSION_NODE:
4449 case PM_PINNED_VARIABLE_NODE:
4450/* Unreachable (indirect writes) **********************************************/
4451 case PM_CALL_TARGET_NODE:
4452 case PM_CLASS_VARIABLE_TARGET_NODE:
4453 case PM_CONSTANT_PATH_TARGET_NODE:
4454 case PM_CONSTANT_TARGET_NODE:
4455 case PM_GLOBAL_VARIABLE_TARGET_NODE:
4456 case PM_INDEX_TARGET_NODE:
4457 case PM_INSTANCE_VARIABLE_TARGET_NODE:
4458 case PM_LOCAL_VARIABLE_TARGET_NODE:
4459 case PM_MULTI_TARGET_NODE:
4460/* Unreachable (clauses) ******************************************************/
4461 case PM_ELSE_NODE:
4462 case PM_ENSURE_NODE:
4463 case PM_IN_NODE:
4464 case PM_RESCUE_NODE:
4465 case PM_WHEN_NODE:
4466/* Unreachable (miscellaneous) ************************************************/
4467 case PM_BLOCK_NODE:
4468 case PM_EMBEDDED_STATEMENTS_NODE:
4469 case PM_EMBEDDED_VARIABLE_NODE:
4470 case PM_MISSING_NODE:
4471 case PM_PRE_EXECUTION_NODE:
4472 case PM_PROGRAM_NODE:
4473 case PM_SCOPE_NODE:
4474 case PM_STATEMENTS_NODE:
4475 rb_bug("Unreachable node in defined?: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
4476 }
4477
4478 RUBY_ASSERT(dtype != DEFINED_NOT_DEFINED);
4479 PUSH_INSN1(ret, location, putobject, PUSH_VAL(dtype));
4480
4481#undef PUSH_VAL
4482}
4483
4484static void
4485pm_defined_expr(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node, bool in_condition, LABEL **lfinish, bool explicit_receiver)
4486{
4487 LINK_ELEMENT *lcur = ret->last;
4488 pm_compile_defined_expr0(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4489
4490 if (lfinish[1]) {
4491 LABEL *lstart = NEW_LABEL(node_location->line);
4492 LABEL *lend = NEW_LABEL(node_location->line);
4493
4494 struct rb_iseq_new_with_callback_callback_func *ifunc =
4495 rb_iseq_new_with_callback_new_callback(build_defined_rescue_iseq, NULL);
4496
4497 const rb_iseq_t *rescue = new_child_iseq_with_callback(
4498 iseq,
4499 ifunc,
4500 rb_str_concat(rb_str_new2("defined guard in "), ISEQ_BODY(iseq)->location.label),
4501 iseq,
4502 ISEQ_TYPE_RESCUE,
4503 0
4504 );
4505
4506 lstart->rescued = LABEL_RESCUE_BEG;
4507 lend->rescued = LABEL_RESCUE_END;
4508
4509 APPEND_LABEL(ret, lcur, lstart);
4510 PUSH_LABEL(ret, lend);
4511 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lfinish[1]);
4512 }
4513}
4514
4515static void
4516pm_compile_defined_expr(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node, bool in_condition)
4517{
4518 LABEL *lfinish[3];
4519 LINK_ELEMENT *last = ret->last;
4520
4521 lfinish[0] = NEW_LABEL(node_location->line);
4522 lfinish[1] = 0;
4523 lfinish[2] = 0;
4524
4525 if (!popped) {
4526 pm_defined_expr(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4527 }
4528
4529 if (lfinish[1]) {
4530 ELEM_INSERT_NEXT(last, &new_insn_body(iseq, node_location->line, node_location->node_id, BIN(putnil), 0)->link);
4531 PUSH_INSN(ret, *node_location, swap);
4532
4533 if (lfinish[2]) PUSH_LABEL(ret, lfinish[2]);
4534 PUSH_INSN(ret, *node_location, pop);
4535 PUSH_LABEL(ret, lfinish[1]);
4536
4537 }
4538
4539 PUSH_LABEL(ret, lfinish[0]);
4540}
4541
4542// This is exactly the same as add_ensure_iseq, except it compiled
4543// the node as a Prism node, and not a CRuby node
4544static void
4545pm_add_ensure_iseq(LINK_ANCHOR *const ret, rb_iseq_t *iseq, int is_return, pm_scope_node_t *scope_node)
4546{
4547 RUBY_ASSERT(can_add_ensure_iseq(iseq));
4548
4549 struct iseq_compile_data_ensure_node_stack *enlp =
4550 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack;
4551 struct iseq_compile_data_ensure_node_stack *prev_enlp = enlp;
4552 DECL_ANCHOR(ensure);
4553
4554 while (enlp) {
4555 if (enlp->erange != NULL) {
4556 DECL_ANCHOR(ensure_part);
4557 LABEL *lstart = NEW_LABEL(0);
4558 LABEL *lend = NEW_LABEL(0);
4559
4560 add_ensure_range(iseq, enlp->erange, lstart, lend);
4561
4562 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enlp->prev;
4563 PUSH_LABEL(ensure_part, lstart);
4564 bool popped = true;
4565 PM_COMPILE_INTO_ANCHOR(ensure_part, (const pm_node_t *) enlp->ensure_node);
4566 PUSH_LABEL(ensure_part, lend);
4567 PUSH_SEQ(ensure, ensure_part);
4568 }
4569 else {
4570 if (!is_return) {
4571 break;
4572 }
4573 }
4574 enlp = enlp->prev;
4575 }
4576 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = prev_enlp;
4577 PUSH_SEQ(ret, ensure);
4578}
4579
4580 struct pm_local_table_insert_ctx {
4581 pm_scope_node_t *scope_node;
4582 rb_ast_id_table_t *local_table_for_iseq;
4583 int local_index;
4584};
4585
4586static int
4587pm_local_table_insert_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
4588{
4589 if (!existing) {
4590 pm_constant_id_t constant_id = (pm_constant_id_t) *key;
4591 struct pm_local_table_insert_ctx * ctx = (struct pm_local_table_insert_ctx *) arg;
4592
4593 pm_scope_node_t *scope_node = ctx->scope_node;
4594 rb_ast_id_table_t *local_table_for_iseq = ctx->local_table_for_iseq;
4595 int local_index = ctx->local_index;
4596
4597 ID local = pm_constant_id_lookup(scope_node, constant_id);
4598 local_table_for_iseq->ids[local_index] = local;
4599
4600 *value = (st_data_t)local_index;
4601
4602 ctx->local_index++;
4603 }
4604
4605 return ST_CONTINUE;
4606}
4607
4613static void
4614pm_insert_local_index(pm_constant_id_t constant_id, int local_index, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq, pm_scope_node_t *scope_node)
4615{
4616 RUBY_ASSERT((constant_id & PM_SPECIAL_CONSTANT_FLAG) == 0);
4617
4618 ID local = pm_constant_id_lookup(scope_node, constant_id);
4619 local_table_for_iseq->ids[local_index] = local;
4620 st_insert(index_lookup_table, (st_data_t) constant_id, (st_data_t) local_index);
4621}
4622
4627static void
4628pm_insert_local_special(ID local_name, int local_index, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq)
4629{
4630 local_table_for_iseq->ids[local_index] = local_name;
4631 st_insert(index_lookup_table, (st_data_t) (local_name | PM_SPECIAL_CONSTANT_FLAG), (st_data_t) local_index);
4632}
4633
4640static int
4641pm_compile_destructured_param_locals(const pm_multi_target_node_t *node, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq, pm_scope_node_t *scope_node, int local_index)
4642{
4643 for (size_t index = 0; index < node->lefts.size; index++) {
4644 const pm_node_t *left = node->lefts.nodes[index];
4645
4646 if (PM_NODE_TYPE_P(left, PM_REQUIRED_PARAMETER_NODE)) {
4647 if (!PM_NODE_FLAG_P(left, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4648 pm_insert_local_index(((const pm_required_parameter_node_t *) left)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4649 local_index++;
4650 }
4651 }
4652 else {
4653 RUBY_ASSERT(PM_NODE_TYPE_P(left, PM_MULTI_TARGET_NODE));
4654 local_index = pm_compile_destructured_param_locals((const pm_multi_target_node_t *) left, index_lookup_table, local_table_for_iseq, scope_node, local_index);
4655 }
4656 }
4657
4658 if (node->rest != NULL && PM_NODE_TYPE_P(node->rest, PM_SPLAT_NODE)) {
4659 const pm_splat_node_t *rest = (const pm_splat_node_t *) node->rest;
4660
4661 if (rest->expression != NULL) {
4662 RUBY_ASSERT(PM_NODE_TYPE_P(rest->expression, PM_REQUIRED_PARAMETER_NODE));
4663
4664 if (!PM_NODE_FLAG_P(rest->expression, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4665 pm_insert_local_index(((const pm_required_parameter_node_t *) rest->expression)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4666 local_index++;
4667 }
4668 }
4669 }
4670
4671 for (size_t index = 0; index < node->rights.size; index++) {
4672 const pm_node_t *right = node->rights.nodes[index];
4673
4674 if (PM_NODE_TYPE_P(right, PM_REQUIRED_PARAMETER_NODE)) {
4675 if (!PM_NODE_FLAG_P(right, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4676 pm_insert_local_index(((const pm_required_parameter_node_t *) right)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4677 local_index++;
4678 }
4679 }
4680 else {
4681 RUBY_ASSERT(PM_NODE_TYPE_P(right, PM_MULTI_TARGET_NODE));
4682 local_index = pm_compile_destructured_param_locals((const pm_multi_target_node_t *) right, index_lookup_table, local_table_for_iseq, scope_node, local_index);
4683 }
4684 }
4685
4686 return local_index;
4687}
4688
4693static inline void
4694pm_compile_destructured_param_write(rb_iseq_t *iseq, const pm_required_parameter_node_t *node, LINK_ANCHOR *const ret, const pm_scope_node_t *scope_node)
4695{
4696 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4697 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, node->name, 0);
4698 PUSH_SETLOCAL(ret, location, index.index, index.level);
4699}
4700
4709static void
4710pm_compile_destructured_param_writes(rb_iseq_t *iseq, const pm_multi_target_node_t *node, LINK_ANCHOR *const ret, const pm_scope_node_t *scope_node)
4711{
4712 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4713 bool has_rest = (node->rest && PM_NODE_TYPE_P(node->rest, PM_SPLAT_NODE) && (((const pm_splat_node_t *) node->rest)->expression) != NULL);
4714 bool has_rights = node->rights.size > 0;
4715
4716 int flag = (has_rest || has_rights) ? 1 : 0;
4717 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->lefts.size), INT2FIX(flag));
4718
4719 for (size_t index = 0; index < node->lefts.size; index++) {
4720 const pm_node_t *left = node->lefts.nodes[index];
4721
4722 if (PM_NODE_TYPE_P(left, PM_REQUIRED_PARAMETER_NODE)) {
4723 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) left, ret, scope_node);
4724 }
4725 else {
4726 RUBY_ASSERT(PM_NODE_TYPE_P(left, PM_MULTI_TARGET_NODE));
4727 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) left, ret, scope_node);
4728 }
4729 }
4730
4731 if (has_rest) {
4732 if (has_rights) {
4733 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->rights.size), INT2FIX(3));
4734 }
4735
4736 const pm_node_t *rest = ((const pm_splat_node_t *) node->rest)->expression;
4737 RUBY_ASSERT(PM_NODE_TYPE_P(rest, PM_REQUIRED_PARAMETER_NODE));
4738
4739 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) rest, ret, scope_node);
4740 }
4741
4742 if (has_rights) {
4743 if (!has_rest) {
4744 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->rights.size), INT2FIX(2));
4745 }
4746
4747 for (size_t index = 0; index < node->rights.size; index++) {
4748 const pm_node_t *right = node->rights.nodes[index];
4749
4750 if (PM_NODE_TYPE_P(right, PM_REQUIRED_PARAMETER_NODE)) {
4751 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) right, ret, scope_node);
4752 }
4753 else {
4754 RUBY_ASSERT(PM_NODE_TYPE_P(right, PM_MULTI_TARGET_NODE));
4755 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) right, ret, scope_node);
4756 }
4757 }
4758 }
4759}
4760
4765 typedef struct pm_multi_target_state_node {
4766 // The pointer to the topn instruction that will need to be modified after
4767 // we know the total stack size of all of the targets.
4768 INSN *topn;
4769
4770 // The index of the stack from the base of the entire multi target at which
4771 // the parent expression is located.
4772 size_t stack_index;
4773
4774 // The number of slots in the stack that this node occupies.
4775 size_t stack_size;
4776
4777 // The position of the node in the list of targets.
4778 size_t position;
4779
4780 // A pointer to the next node in this linked list.
4781 struct pm_multi_target_state_node *next;
4782} pm_multi_target_state_node_t;
4783
4791 typedef struct {
4792 // The total number of slots in the stack that this multi target occupies.
4793 size_t stack_size;
4794
4795 // The position of the current node being compiled. This is forwarded to
4796 // nodes when they are allocated.
4797 size_t position;
4798
4799 // A pointer to the head of this linked list.
4800 pm_multi_target_state_node_t *head;
4801
4802 // A pointer to the tail of this linked list.
4803 pm_multi_target_state_node_t *tail;
4804} pm_multi_target_state_t;
4805
4809static void
4810pm_multi_target_state_push(pm_multi_target_state_t *state, INSN *topn, size_t stack_size)
4811{
4812 pm_multi_target_state_node_t *node = ALLOC(pm_multi_target_state_node_t);
4813 node->topn = topn;
4814 node->stack_index = state->stack_size + 1;
4815 node->stack_size = stack_size;
4816 node->position = state->position;
4817 node->next = NULL;
4818
4819 if (state->head == NULL) {
4820 state->head = node;
4821 state->tail = node;
4822 }
4823 else {
4824 state->tail->next = node;
4825 state->tail = node;
4826 }
4827
4828 state->stack_size += stack_size;
4829}
4830
4836static void
4837pm_multi_target_state_update(pm_multi_target_state_t *state)
4838{
4839 // If nothing was ever pushed onto the stack, then we don't need to do any
4840 // kind of updates.
4841 if (state->stack_size == 0) return;
4842
4843 pm_multi_target_state_node_t *current = state->head;
4844 pm_multi_target_state_node_t *previous;
4845
4846 while (current != NULL) {
4847 VALUE offset = INT2FIX(state->stack_size - current->stack_index + current->position);
4848 current->topn->operands[0] = offset;
4849
4850 // stack_size will be > 1 in the case that we compiled an index target
4851 // and it had arguments. In this case, we use multiple topn instructions
4852 // to grab up all of the arguments as well, so those offsets need to be
4853 // updated as well.
4854 if (current->stack_size > 1) {
4855 INSN *insn = current->topn;
4856
4857 for (size_t index = 1; index < current->stack_size; index += 1) {
4858 LINK_ELEMENT *element = get_next_insn(insn);
4859 RUBY_ASSERT(IS_INSN(element));
4860
4861 insn = (INSN *) element;
4862 RUBY_ASSERT(insn->insn_id == BIN(topn));
4863
4864 insn->operands[0] = offset;
4865 }
4866 }
4867
4868 previous = current;
4869 current = current->next;
4870
4871 xfree(previous);
4872 }
4873}
4874
4875static void
4876pm_compile_multi_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const parents, LINK_ANCHOR *const writes, LINK_ANCHOR *const cleanup, pm_scope_node_t *scope_node, pm_multi_target_state_t *state);
4877
4906static void
4907pm_compile_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const parents, LINK_ANCHOR *const writes, LINK_ANCHOR *const cleanup, pm_scope_node_t *scope_node, pm_multi_target_state_t *state)
4908{
4909 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4910
4911 switch (PM_NODE_TYPE(node)) {
4912 case PM_LOCAL_VARIABLE_TARGET_NODE: {
4913 // Local variable targets have no parent expression, so they only need
4914 // to compile the write.
4915 //
4916 // for i in []; end
4917 //
4918 const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
4919 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
4920
4921 PUSH_SETLOCAL(writes, location, index.index, index.level);
4922 break;
4923 }
4924 case PM_CLASS_VARIABLE_TARGET_NODE: {
4925 // Class variable targets have no parent expression, so they only need
4926 // to compile the write.
4927 //
4928 // for @@i in []; end
4929 //
4930 const pm_class_variable_target_node_t *cast = (const pm_class_variable_target_node_t *) node;
4931 ID name = pm_constant_id_lookup(scope_node, cast->name);
4932
4933 VALUE operand = ID2SYM(name);
4934 PUSH_INSN2(writes, location, setclassvariable, operand, get_cvar_ic_value(iseq, name));
4935 break;
4936 }
4937 case PM_CONSTANT_TARGET_NODE: {
4938 // Constant targets have no parent expression, so they only need to
4939 // compile the write.
4940 //
4941 // for I in []; end
4942 //
4943 const pm_constant_target_node_t *cast = (const pm_constant_target_node_t *) node;
4944 ID name = pm_constant_id_lookup(scope_node, cast->name);
4945
4946 VALUE operand = ID2SYM(name);
4947 PUSH_INSN1(writes, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
4948 PUSH_INSN1(writes, location, setconstant, operand);
4949 break;
4950 }
4951 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
4952 // Global variable targets have no parent expression, so they only need
4953 // to compile the write.
4954 //
4955 // for $i in []; end
4956 //
4957 const pm_global_variable_target_node_t *cast = (const pm_global_variable_target_node_t *) node;
4958 ID name = pm_constant_id_lookup(scope_node, cast->name);
4959
4960 VALUE operand = ID2SYM(name);
4961 PUSH_INSN1(writes, location, setglobal, operand);
4962 break;
4963 }
4964 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
4965 // Instance variable targets have no parent expression, so they only
4966 // need to compile the write.
4967 //
4968 // for @i in []; end
4969 //
4970 const pm_instance_variable_target_node_t *cast = (const pm_instance_variable_target_node_t *) node;
4971 ID name = pm_constant_id_lookup(scope_node, cast->name);
4972
4973 VALUE operand = ID2SYM(name);
4974 PUSH_INSN2(writes, location, setinstancevariable, operand, get_ivar_ic_value(iseq, name));
4975 break;
4976 }
4977 case PM_CONSTANT_PATH_TARGET_NODE: {
4978 // Constant path targets have a parent expression that is the object
4979 // that owns the constant. This needs to be compiled first into the
4980 // parents sequence. If no parent is found, then it represents using the
4981 // unary :: operator to indicate a top-level constant. In that case we
4982 // need to push Object onto the stack.
4983 //
4984 // for I::J in []; end
4985 //
4986 const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
4987 ID name = pm_constant_id_lookup(scope_node, cast->name);
4988
4989 if (cast->parent != NULL) {
4990 pm_compile_node(iseq, cast->parent, parents, false, scope_node);
4991 }
4992 else {
4993 PUSH_INSN1(parents, location, putobject, rb_cObject);
4994 }
4995
4996 if (state == NULL) {
4997 PUSH_INSN(writes, location, swap);
4998 }
4999 else {
5000 PUSH_INSN1(writes, location, topn, INT2FIX(1));
5001 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
5002 }
5003
5004 VALUE operand = ID2SYM(name);
5005 PUSH_INSN1(writes, location, setconstant, operand);
5006
5007 if (state != NULL) {
5008 PUSH_INSN(cleanup, location, pop);
5009 }
5010
5011 break;
5012 }
5013 case PM_CALL_TARGET_NODE: {
5014 // Call targets have a parent expression that is the receiver of the
5015 // method being called. This needs to be compiled first into the parents
5016 // sequence. These nodes cannot have arguments, so the method call is
5017 // compiled with a single argument which represents the value being
5018 // written.
5019 //
5020 // for i.j in []; end
5021 //
5022 const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
5023 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
5024
5025 pm_compile_node(iseq, cast->receiver, parents, false, scope_node);
5026
5027 LABEL *safe_label = NULL;
5028 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5029 safe_label = NEW_LABEL(location.line);
5030 PUSH_INSN(parents, location, dup);
5031 PUSH_INSNL(parents, location, branchnil, safe_label);
5032 }
5033
5034 if (state != NULL) {
5035 PUSH_INSN1(writes, location, topn, INT2FIX(1));
5036 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
5037 PUSH_INSN(writes, location, swap);
5038 }
5039
5040 int flags = VM_CALL_ARGS_SIMPLE;
5041 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) flags |= VM_CALL_FCALL;
5042
5043 PUSH_SEND_WITH_FLAG(writes, location, method_id, INT2FIX(1), INT2FIX(flags));
5044 if (safe_label != NULL && state == NULL) PUSH_LABEL(writes, safe_label);
5045 PUSH_INSN(writes, location, pop);
5046 if (safe_label != NULL && state != NULL) PUSH_LABEL(writes, safe_label);
5047
5048 if (state != NULL) {
5049 PUSH_INSN(cleanup, location, pop);
5050 }
5051
5052 break;
5053 }
5054 case PM_INDEX_TARGET_NODE: {
5055 // Index targets have a parent expression that is the receiver of the
5056 // method being called and any additional arguments that are being
5057 // passed along with the value being written. The receiver and arguments
5058 // both need to be on the stack. Note that this is even more complicated
5059 // by the fact that these nodes can hold a block using the unary &
5060 // operator.
5061 //
5062 // for i[:j] in []; end
5063 //
5064 const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
5065
5066 pm_compile_node(iseq, cast->receiver, parents, false, scope_node);
5067
5068 int flags = 0;
5069 struct rb_callinfo_kwarg *kwargs = NULL;
5070 int argc = pm_setup_args(cast->arguments, (const pm_node_t *) cast->block, &flags, &kwargs, iseq, parents, scope_node, &location);
5071
5072 if (state != NULL) {
5073 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5074 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), argc + 1);
5075
5076 if (argc == 0) {
5077 PUSH_INSN(writes, location, swap);
5078 }
5079 else {
5080 for (int index = 0; index < argc; index++) {
5081 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5082 }
5083 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5084 }
5085 }
5086
5087 // The argc that we're going to pass to the send instruction is the
5088 // number of arguments + 1 for the value being written. If there's a
5089 // splat, then we need to insert newarray and concatarray instructions
5090 // after the arguments have been written.
5091 int ci_argc = argc + 1;
5092 if (flags & VM_CALL_ARGS_SPLAT) {
5093 ci_argc--;
5094 PUSH_INSN1(writes, location, newarray, INT2FIX(1));
5095 PUSH_INSN(writes, location, concatarray);
5096 }
5097
5098 PUSH_SEND_R(writes, location, idASET, INT2NUM(ci_argc), NULL, INT2FIX(flags), kwargs);
5099 PUSH_INSN(writes, location, pop);
5100
5101 if (state != NULL) {
5102 if (argc != 0) {
5103 PUSH_INSN(writes, location, pop);
5104 }
5105
5106 for (int index = 0; index < argc + 1; index++) {
5107 PUSH_INSN(cleanup, location, pop);
5108 }
5109 }
5110
5111 break;
5112 }
5113 case PM_MULTI_TARGET_NODE: {
5114 // Multi target nodes represent a set of writes to multiple variables.
5115 // The parent expressions are the combined set of the parent expressions
5116 // of its inner target nodes.
5117 //
5118 // for i, j in []; end
5119 //
5120 size_t before_position;
5121 if (state != NULL) {
5122 before_position = state->position;
5123 state->position--;
5124 }
5125
5126 pm_compile_multi_target_node(iseq, node, parents, writes, cleanup, scope_node, state);
5127 if (state != NULL) state->position = before_position;
5128
5129 break;
5130 }
5131 case PM_SPLAT_NODE: {
5132 // Splat nodes capture all values into an array. They can be used
5133 // as targets in assignments or for loops.
5134 //
5135 // for *x in []; end
5136 //
5137 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
5138
5139 if (cast->expression != NULL) {
5140 pm_compile_target_node(iseq, cast->expression, parents, writes, cleanup, scope_node, state);
5141 }
5142
5143 break;
5144 }
5145 default:
5146 rb_bug("Unexpected node type: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5147 break;
5148 }
5149}
5150
5156static void
5157pm_compile_multi_target_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const parents, LINK_ANCHOR *const writes, LINK_ANCHOR *const cleanup, pm_scope_node_t *scope_node, pm_multi_target_state_t *state)
5158{
5159 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5160 const pm_node_list_t *lefts;
5161 const pm_node_t *rest;
5162 const pm_node_list_t *rights;
5163
5164 switch (PM_NODE_TYPE(node)) {
5165 case PM_MULTI_TARGET_NODE: {
5166 const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
5167 lefts = &cast->lefts;
5168 rest = cast->rest;
5169 rights = &cast->rights;
5170 break;
5171 }
5172 case PM_MULTI_WRITE_NODE: {
5173 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
5174 lefts = &cast->lefts;
5175 rest = cast->rest;
5176 rights = &cast->rights;
5177 break;
5178 }
5179 default:
5180 rb_bug("Unsupported node %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5181 break;
5182 }
5183
5184 bool has_rest = (rest != NULL) && PM_NODE_TYPE_P(rest, PM_SPLAT_NODE) && ((const pm_splat_node_t *) rest)->expression != NULL;
5185 bool has_posts = rights->size > 0;
5186
5187 // The first instruction in the writes sequence is going to spread the
5188 // top value of the stack onto the number of values that we're going to
5189 // write.
5190 PUSH_INSN2(writes, location, expandarray, INT2FIX(lefts->size), INT2FIX((has_rest || has_posts) ? 1 : 0));
5191
5192 // We need to keep track of some additional state information as we're
5193 // going through the targets because we will need to revisit them once
5194 // we know how many values are being pushed onto the stack.
5195 pm_multi_target_state_t target_state = { 0 };
5196 if (state == NULL) state = &target_state;
5197
5198 size_t base_position = state->position;
5199 size_t splat_position = (has_rest || has_posts) ? 1 : 0;
5200
5201 // Next, we'll iterate through all of the leading targets.
5202 for (size_t index = 0; index < lefts->size; index++) {
5203 const pm_node_t *target = lefts->nodes[index];
5204 state->position = lefts->size - index + splat_position + base_position;
5205 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5206 }
5207
5208 // Next, we'll compile the rest target if there is one.
5209 if (has_rest) {
5210 const pm_node_t *target = ((const pm_splat_node_t *) rest)->expression;
5211 state->position = 1 + rights->size + base_position;
5212
5213 if (has_posts) {
5214 PUSH_INSN2(writes, location, expandarray, INT2FIX(rights->size), INT2FIX(3));
5215 }
5216
5217 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5218 }
5219
5220 // Finally, we'll compile the trailing targets.
5221 if (has_posts) {
5222 if (!has_rest && rest != NULL) {
5223 PUSH_INSN2(writes, location, expandarray, INT2FIX(rights->size), INT2FIX(2));
5224 }
5225
5226 for (size_t index = 0; index < rights->size; index++) {
5227 const pm_node_t *target = rights->nodes[index];
5228 state->position = rights->size - index + base_position;
5229 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5230 }
5231 }
5232}
5233
5239static void
5240pm_compile_for_node_index(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node)
5241{
5242 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5243
5244 switch (PM_NODE_TYPE(node)) {
5245 case PM_LOCAL_VARIABLE_TARGET_NODE: {
5246 // For local variables, all we have to do is retrieve the value and then
5247 // compile the index node.
5248 PUSH_GETLOCAL(ret, location, 1, 0);
5249 pm_compile_target_node(iseq, node, ret, ret, ret, scope_node, NULL);
5250 break;
5251 }
5252 case PM_CLASS_VARIABLE_TARGET_NODE:
5253 case PM_CONSTANT_TARGET_NODE:
5254 case PM_GLOBAL_VARIABLE_TARGET_NODE:
5255 case PM_INSTANCE_VARIABLE_TARGET_NODE:
5256 case PM_CONSTANT_PATH_TARGET_NODE:
5257 case PM_CALL_TARGET_NODE:
5258 case PM_INDEX_TARGET_NODE:
5259 case PM_SPLAT_NODE: {
5260 // For other targets, we need to potentially compile the parent or
5261 // owning expression of this target, then retrieve the value, expand it,
5262 // and then compile the necessary writes.
5263 DECL_ANCHOR(writes);
5264 DECL_ANCHOR(cleanup);
5265
5266 pm_multi_target_state_t state = { 0 };
5267 state.position = 1;
5268 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
5269
5270 PUSH_GETLOCAL(ret, location, 1, 0);
5271 PUSH_INSN2(ret, location, expandarray, INT2FIX(1), INT2FIX(0));
5272
5273 PUSH_SEQ(ret, writes);
5274 PUSH_SEQ(ret, cleanup);
5275
5276 pm_multi_target_state_update(&state);
5277 break;
5278 }
5279 case PM_MULTI_TARGET_NODE: {
5280 DECL_ANCHOR(writes);
5281 DECL_ANCHOR(cleanup);
5282
5283 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, NULL);
5284
5285 LABEL *not_single = NEW_LABEL(location.line);
5286 LABEL *not_ary = NEW_LABEL(location.line);
5287
5288 // When there are multiple targets, we'll do a bunch of work to convert
5289 // the value into an array before we expand it. Effectively we're trying
5290 // to accomplish:
5291 //
5292 // (args.length == 1 && Array.try_convert(args[0])) || args
5293 //
5294 PUSH_GETLOCAL(ret, location, 1, 0);
5295 PUSH_INSN(ret, location, dup);
5296 PUSH_CALL(ret, location, idLength, INT2FIX(0));
5297 PUSH_INSN1(ret, location, putobject, INT2FIX(1));
5298 PUSH_CALL(ret, location, idEq, INT2FIX(1));
5299 PUSH_INSNL(ret, location, branchunless, not_single);
5300 PUSH_INSN(ret, location, dup);
5301 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
5302 PUSH_CALL(ret, location, idAREF, INT2FIX(1));
5303 PUSH_INSN1(ret, location, putobject, rb_cArray);
5304 PUSH_INSN(ret, location, swap);
5305 PUSH_CALL(ret, location, rb_intern("try_convert"), INT2FIX(1));
5306 PUSH_INSN(ret, location, dup);
5307 PUSH_INSNL(ret, location, branchunless, not_ary);
5308 PUSH_INSN(ret, location, swap);
5309
5310 PUSH_LABEL(ret, not_ary);
5311 PUSH_INSN(ret, location, pop);
5312
5313 PUSH_LABEL(ret, not_single);
5314 PUSH_SEQ(ret, writes);
5315 PUSH_SEQ(ret, cleanup);
5316 break;
5317 }
5318 default:
5319 rb_bug("Unexpected node type for index in for node: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5320 break;
5321 }
5322}
5323
5324static void
5325pm_compile_rescue(rb_iseq_t *iseq, const pm_begin_node_t *cast, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5326{
5327 const pm_parser_t *parser = scope_node->parser;
5328
5329 LABEL *lstart = NEW_LABEL(node_location->line);
5330 LABEL *lend = NEW_LABEL(node_location->line);
5331 LABEL *lcont = NEW_LABEL(node_location->line);
5332
5333 pm_scope_node_t rescue_scope_node;
5334 pm_scope_node_init((const pm_node_t *) cast->rescue_clause, &rescue_scope_node, scope_node);
5335
5336 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
5337 &rescue_scope_node,
5338 rb_str_concat(rb_str_new2("rescue in "), ISEQ_BODY(iseq)->location.label),
5339 ISEQ_TYPE_RESCUE,
5340 pm_node_line_number(parser, (const pm_node_t *) cast->rescue_clause)
5341 );
5342
5343 pm_scope_node_destroy(&rescue_scope_node);
5344
5345 lstart->rescued = LABEL_RESCUE_BEG;
5346 lend->rescued = LABEL_RESCUE_END;
5347 PUSH_LABEL(ret, lstart);
5348
5349 bool prev_in_rescue = ISEQ_COMPILE_DATA(iseq)->in_rescue;
5350 ISEQ_COMPILE_DATA(iseq)->in_rescue = true;
5351
5352 if (cast->statements != NULL) {
5353 PM_COMPILE_NOT_POPPED((const pm_node_t *) cast->statements);
5354 }
5355 else {
5356 const pm_node_location_t location = PM_NODE_START_LOCATION(parser, cast->rescue_clause);
5357 PUSH_INSN(ret, location, putnil);
5358 }
5359
5360 ISEQ_COMPILE_DATA(iseq)->in_rescue = prev_in_rescue;
5361 PUSH_LABEL(ret, lend);
5362
5363 if (cast->else_clause != NULL) {
5364 if (!popped) PUSH_INSN(ret, *node_location, pop);
5365 PM_COMPILE((const pm_node_t *) cast->else_clause);
5366 }
5367
5368 PUSH_INSN(ret, *node_location, nop);
5369 PUSH_LABEL(ret, lcont);
5370
5371 if (popped) PUSH_INSN(ret, *node_location, pop);
5372 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
5373 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
5374}
5375
5376static void
5377pm_compile_ensure(rb_iseq_t *iseq, const pm_begin_node_t *cast, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5378{
5379 const pm_parser_t *parser = scope_node->parser;
5380 const pm_statements_node_t *statements = cast->ensure_clause->statements;
5381
5382 pm_node_location_t location;
5383 if (statements != NULL) {
5384 location = PM_NODE_START_LOCATION(parser, statements);
5385 }
5386 else {
5387 location = *node_location;
5388 }
5389
5390 LABEL *lstart = NEW_LABEL(location.line);
5391 LABEL *lend = NEW_LABEL(location.line);
5392 LABEL *lcont = NEW_LABEL(location.line);
5393
5394 struct ensure_range er;
5395 struct iseq_compile_data_ensure_node_stack enl;
5396 struct ensure_range *erange;
5397
5398 DECL_ANCHOR(ensr);
5399 if (statements != NULL) {
5400 pm_compile_node(iseq, (const pm_node_t *) statements, ensr, true, scope_node);
5401 }
5402
5403 LINK_ELEMENT *last = ensr->last;
5404 bool last_leave = last && IS_INSN(last) && IS_INSN_ID(last, leave);
5405
5406 er.begin = lstart;
5407 er.end = lend;
5408 er.next = 0;
5409 push_ensure_entry(iseq, &enl, &er, (void *) cast->ensure_clause);
5410
5411 PUSH_LABEL(ret, lstart);
5412 if (cast->rescue_clause != NULL) {
5413 pm_compile_rescue(iseq, cast, node_location, ret, popped | last_leave, scope_node);
5414 }
5415 else if (cast->statements != NULL) {
5416 pm_compile_node(iseq, (const pm_node_t *) cast->statements, ret, popped | last_leave, scope_node);
5417 }
5418 else if (!(popped | last_leave)) {
5419 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
5420 }
5421
5422 PUSH_LABEL(ret, lend);
5423 PUSH_SEQ(ret, ensr);
5424 if (!popped && last_leave) PUSH_INSN(ret, *node_location, putnil);
5425 PUSH_LABEL(ret, lcont);
5426 if (last_leave) PUSH_INSN(ret, *node_location, pop);
5427
5428 pm_scope_node_t next_scope_node;
5429 pm_scope_node_init((const pm_node_t *) cast->ensure_clause, &next_scope_node, scope_node);
5430
5431 rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(
5432 &next_scope_node,
5433 rb_str_concat(rb_str_new2("ensure in "), ISEQ_BODY(iseq)->location.label),
5434 ISEQ_TYPE_ENSURE,
5435 location.line
5436 );
5437
5438 pm_scope_node_destroy(&next_scope_node);
5439
5440 erange = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->erange;
5441 if (lstart->link.next != &lend->link) {
5442 while (erange) {
5443 PUSH_CATCH_ENTRY(CATCH_TYPE_ENSURE, erange->begin, erange->end, child_iseq, lcont);
5444 erange = erange->next;
5445 }
5446 }
5447 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enl.prev;
5448}
5449
5454static inline bool
5455pm_opt_str_freeze_p(const rb_iseq_t *iseq, const pm_call_node_t *node)
5456{
5457 return (
5458 !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) &&
5459 node->receiver != NULL &&
5460 PM_NODE_TYPE_P(node->receiver, PM_STRING_NODE) &&
5461 node->arguments == NULL &&
5462 node->block == NULL &&
5463 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5464 );
5465}
5466
5471static inline bool
5472pm_opt_aref_with_p(const rb_iseq_t *iseq, const pm_call_node_t *node)
5473{
5474 return (
5475 !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) &&
5476 node->arguments != NULL &&
5477 PM_NODE_TYPE_P((const pm_node_t *) node->arguments, PM_ARGUMENTS_NODE) &&
5478 ((const pm_arguments_node_t *) node->arguments)->arguments.size == 1 &&
5479 PM_NODE_TYPE_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_NODE) &&
5480 node->block == NULL &&
5481 !PM_NODE_FLAG_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_FLAGS_FROZEN) &&
5482 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5483 );
5484}
5485
5490static inline bool
5491pm_opt_aset_with_p(const rb_iseq_t *iseq, const pm_call_node_t *node)
5492{
5493 return (
5494 !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) &&
5495 node->arguments != NULL &&
5496 PM_NODE_TYPE_P((const pm_node_t *) node->arguments, PM_ARGUMENTS_NODE) &&
5497 ((const pm_arguments_node_t *) node->arguments)->arguments.size == 2 &&
5498 PM_NODE_TYPE_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_NODE) &&
5499 node->block == NULL &&
5500 !PM_NODE_FLAG_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_FLAGS_FROZEN) &&
5501 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5502 );
5503}
5504
5509static void
5510pm_compile_constant_read(rb_iseq_t *iseq, VALUE name, const pm_location_t *name_loc, uint32_t node_id, LINK_ANCHOR *const ret, const pm_scope_node_t *scope_node)
5511{
5512 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, name_loc, node_id);
5513
5514 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache) {
5515 ISEQ_BODY(iseq)->ic_size++;
5516 VALUE segments = rb_ary_new_from_args(1, name);
5517 PUSH_INSN1(ret, location, opt_getconstant_path, segments);
5518 }
5519 else {
5520 PUSH_INSN(ret, location, putnil);
5521 PUSH_INSN1(ret, location, putobject, Qtrue);
5522 PUSH_INSN1(ret, location, getconstant, name);
5523 }
5524}
5525
5530static VALUE
5531pm_constant_path_parts(const pm_node_t *node, const pm_scope_node_t *scope_node)
5532{
5533 VALUE parts = rb_ary_new();
5534
5535 while (true) {
5536 switch (PM_NODE_TYPE(node)) {
5537 case PM_CONSTANT_READ_NODE: {
5538 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
5539 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5540
5541 rb_ary_unshift(parts, name);
5542 return parts;
5543 }
5544 case PM_CONSTANT_PATH_NODE: {
5545 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
5546 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5547
5548 rb_ary_unshift(parts, name);
5549 if (cast->parent == NULL) {
5550 rb_ary_unshift(parts, ID2SYM(idNULL));
5551 return parts;
5552 }
5553
5554 node = cast->parent;
5555 break;
5556 }
5557 default:
5558 return Qnil;
5559 }
5560 }
5561}
5562
5568static void
5569pm_compile_constant_path(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const prefix, LINK_ANCHOR *const body, bool popped, pm_scope_node_t *scope_node)
5570{
5571 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5572
5573 switch (PM_NODE_TYPE(node)) {
5574 case PM_CONSTANT_READ_NODE: {
5575 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
5576 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5577
5578 PUSH_INSN1(body, location, putobject, Qtrue);
5579 PUSH_INSN1(body, location, getconstant, name);
5580 break;
5581 }
5582 case PM_CONSTANT_PATH_NODE: {
5583 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
5584 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5585
5586 if (cast->parent == NULL) {
5587 PUSH_INSN(body, location, pop);
5588 PUSH_INSN1(body, location, putobject, rb_cObject);
5589 PUSH_INSN1(body, location, putobject, Qtrue);
5590 PUSH_INSN1(body, location, getconstant, name);
5591 }
5592 else {
5593 pm_compile_constant_path(iseq, cast->parent, prefix, body, false, scope_node);
5594 PUSH_INSN1(body, location, putobject, Qfalse);
5595 PUSH_INSN1(body, location, getconstant, name);
5596 }
5597 break;
5598 }
5599 default:
5600 PM_COMPILE_INTO_ANCHOR(prefix, node);
5601 break;
5602 }
5603}
5604
5608static VALUE
5609pm_compile_shareable_constant_literal(rb_iseq_t *iseq, const pm_node_t *node, const pm_scope_node_t *scope_node)
5610{
5611 switch (PM_NODE_TYPE(node)) {
5612 case PM_TRUE_NODE:
5613 case PM_FALSE_NODE:
5614 case PM_NIL_NODE:
5615 case PM_SYMBOL_NODE:
5616 case PM_REGULAR_EXPRESSION_NODE:
5617 case PM_SOURCE_LINE_NODE:
5618 case PM_INTEGER_NODE:
5619 case PM_FLOAT_NODE:
5620 case PM_RATIONAL_NODE:
5621 case PM_IMAGINARY_NODE:
5622 case PM_SOURCE_ENCODING_NODE:
5623 return pm_static_literal_value(iseq, node, scope_node);
5624 case PM_STRING_NODE:
5625 return parse_static_literal_string(iseq, scope_node, node, &((const pm_string_node_t *) node)->unescaped);
5626 case PM_SOURCE_FILE_NODE:
5627 return pm_source_file_value((const pm_source_file_node_t *) node, scope_node);
5628 case PM_ARRAY_NODE: {
5629 const pm_array_node_t *cast = (const pm_array_node_t *) node;
5630 VALUE result = rb_ary_new_capa(cast->elements.size);
5631
5632 for (size_t index = 0; index < cast->elements.size; index++) {
5633 VALUE element = pm_compile_shareable_constant_literal(iseq, cast->elements.nodes[index], scope_node);
5634 if (element == Qundef) return Qundef;
5635
5636 rb_ary_push(result, element);
5637 }
5638
5639 return rb_ractor_make_shareable(result);
5640 }
5641 case PM_HASH_NODE: {
5642 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
5643 VALUE result = rb_hash_new_capa(cast->elements.size);
5644
5645 for (size_t index = 0; index < cast->elements.size; index++) {
5646 const pm_node_t *element = cast->elements.nodes[index];
5647 if (!PM_NODE_TYPE_P(element, PM_ASSOC_NODE)) return Qundef;
5648
5649 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
5650
5651 VALUE key = pm_compile_shareable_constant_literal(iseq, assoc->key, scope_node);
5652 if (key == Qundef) return Qundef;
5653
5654 VALUE value = pm_compile_shareable_constant_literal(iseq, assoc->value, scope_node);
5655 if (value == Qundef) return Qundef;
5656
5657 rb_hash_aset(result, key, value);
5658 }
5659
5660 return rb_ractor_make_shareable(result);
5661 }
5662 default:
5663 return Qundef;
5664 }
5665}
5666
5671static void
5672pm_compile_shareable_constant_value(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_flags_t shareability, VALUE path, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node, bool top)
5673{
5674 VALUE literal = pm_compile_shareable_constant_literal(iseq, node, scope_node);
5675 if (literal != Qundef) {
5676 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5677 PUSH_INSN1(ret, location, putobject, literal);
5678 return;
5679 }
5680
5681 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5682 switch (PM_NODE_TYPE(node)) {
5683 case PM_ARRAY_NODE: {
5684 const pm_array_node_t *cast = (const pm_array_node_t *) node;
5685
5686 if (top) {
5687 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5688 }
5689
5690 for (size_t index = 0; index < cast->elements.size; index++) {
5691 pm_compile_shareable_constant_value(iseq, cast->elements.nodes[index], shareability, path, ret, scope_node, false);
5692 }
5693
5694 PUSH_INSN1(ret, location, newarray, INT2FIX(cast->elements.size));
5695
5696 if (top) {
5697 ID method_id = (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) ? rb_intern("make_shareable_copy") : rb_intern("make_shareable");
5698 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5699 }
5700
5701 return;
5702 }
5703 case PM_HASH_NODE: {
5704 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
5705
5706 if (top) {
5707 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5708 }
5709
5710 pm_compile_hash_elements(iseq, (const pm_node_t *) cast, &cast->elements, shareability, path, false, ret, scope_node);
5711
5712 if (top) {
5713 ID method_id = (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) ? rb_intern("make_shareable_copy") : rb_intern("make_shareable");
5714 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5715 }
5716
5717 return;
5718 }
5719 default: {
5720 DECL_ANCHOR(value_seq);
5721
5722 pm_compile_node(iseq, node, value_seq, false, scope_node);
5723 if (PM_NODE_TYPE_P(node, PM_INTERPOLATED_STRING_NODE)) {
5724 PUSH_SEND_WITH_FLAG(value_seq, location, idUMinus, INT2FIX(0), INT2FIX(VM_CALL_ARGS_SIMPLE));
5725 }
5726
5727 if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL) {
5728 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5729 PUSH_SEQ(ret, value_seq);
5730 PUSH_INSN1(ret, location, putobject, path);
5731 PUSH_SEND_WITH_FLAG(ret, location, rb_intern("ensure_shareable"), INT2FIX(2), INT2FIX(VM_CALL_ARGS_SIMPLE));
5732 }
5733 else if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) {
5734 if (top) PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5735 PUSH_SEQ(ret, value_seq);
5736 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern("make_shareable_copy"), INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5737 }
5738 else if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING) {
5739 if (top) PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5740 PUSH_SEQ(ret, value_seq);
5741 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern("make_shareable"), INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5742 }
5743
5744 break;
5745 }
5746 }
5747}
5748
5753static void
5754pm_compile_constant_write_node(rb_iseq_t *iseq, const pm_constant_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5755{
5756 const pm_node_location_t location = *node_location;
5757 ID name_id = pm_constant_id_lookup(scope_node, node->name);
5758
5759 if (shareability != 0) {
5760 pm_compile_shareable_constant_value(iseq, node->value, shareability, rb_id2str(name_id), ret, scope_node, true);
5761 }
5762 else {
5763 PM_COMPILE_NOT_POPPED(node->value);
5764 }
5765
5766 if (!popped) PUSH_INSN(ret, location, dup);
5767 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5768
5769 VALUE operand = ID2SYM(name_id);
5770 PUSH_INSN1(ret, location, setconstant, operand);
5771}
5772
5777static void
5778pm_compile_constant_and_write_node(rb_iseq_t *iseq, const pm_constant_and_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5779{
5780 const pm_node_location_t location = *node_location;
5781
5782 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5783 LABEL *end_label = NEW_LABEL(location.line);
5784
5785 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5786 if (!popped) PUSH_INSN(ret, location, dup);
5787
5788 PUSH_INSNL(ret, location, branchunless, end_label);
5789 if (!popped) PUSH_INSN(ret, location, pop);
5790
5791 if (shareability != 0) {
5792 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5793 }
5794 else {
5795 PM_COMPILE_NOT_POPPED(node->value);
5796 }
5797
5798 if (!popped) PUSH_INSN(ret, location, dup);
5799 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5800 PUSH_INSN1(ret, location, setconstant, name);
5801 PUSH_LABEL(ret, end_label);
5802}
5803
5808static void
5809pm_compile_constant_or_write_node(rb_iseq_t *iseq, const pm_constant_or_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5810{
5811 const pm_node_location_t location = *node_location;
5812 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5813
5814 LABEL *set_label = NEW_LABEL(location.line);
5815 LABEL *end_label = NEW_LABEL(location.line);
5816
5817 PUSH_INSN(ret, location, putnil);
5818 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST), name, Qtrue);
5819 PUSH_INSNL(ret, location, branchunless, set_label);
5820
5821 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5822 if (!popped) PUSH_INSN(ret, location, dup);
5823
5824 PUSH_INSNL(ret, location, branchif, end_label);
5825 if (!popped) PUSH_INSN(ret, location, pop);
5826 PUSH_LABEL(ret, set_label);
5827
5828 if (shareability != 0) {
5829 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5830 }
5831 else {
5832 PM_COMPILE_NOT_POPPED(node->value);
5833 }
5834
5835 if (!popped) PUSH_INSN(ret, location, dup);
5836 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5837 PUSH_INSN1(ret, location, setconstant, name);
5838 PUSH_LABEL(ret, end_label);
5839}
5840
5845static void
5846pm_compile_constant_operator_write_node(rb_iseq_t *iseq, const pm_constant_operator_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5847{
5848 const pm_node_location_t location = *node_location;
5849
5850 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5851 ID method_id = pm_constant_id_lookup(scope_node, node->binary_operator);
5852
5853 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5854
5855 if (shareability != 0) {
5856 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5857 }
5858 else {
5859 PM_COMPILE_NOT_POPPED(node->value);
5860 }
5861
5862 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5863 if (!popped) PUSH_INSN(ret, location, dup);
5864
5865 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5866 PUSH_INSN1(ret, location, setconstant, name);
5867}
5868
5873static VALUE
5874pm_constant_path_path(const pm_constant_path_node_t *node, const pm_scope_node_t *scope_node)
5875{
5876 VALUE parts = rb_ary_new();
5877 rb_ary_push(parts, rb_id2str(pm_constant_id_lookup(scope_node, node->name)));
5878
5879 const pm_node_t *current = node->parent;
5880 while (current != NULL && PM_NODE_TYPE_P(current, PM_CONSTANT_PATH_NODE)) {
5881 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) current;
5882 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, cast->name)));
5883 current = cast->parent;
5884 }
5885
5886 if (current == NULL) {
5887 rb_ary_unshift(parts, rb_id2str(idNULL));
5888 }
5889 else if (PM_NODE_TYPE_P(current, PM_CONSTANT_READ_NODE)) {
5890 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, ((const pm_constant_read_node_t *) current)->name)));
5891 }
5892 else {
5893 rb_ary_unshift(parts, rb_str_new_cstr("..."));
5894 }
5895
5896 return rb_ary_join(parts, rb_str_new_cstr("::"));
5897}
5898
5903static void
5904pm_compile_constant_path_write_node(rb_iseq_t *iseq, const pm_constant_path_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5905{
5906 const pm_node_location_t location = *node_location;
5907 const pm_constant_path_node_t *target = node->target;
5908 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5909
5910 if (target->parent) {
5911 PM_COMPILE_NOT_POPPED((const pm_node_t *) target->parent);
5912 }
5913 else {
5914 PUSH_INSN1(ret, location, putobject, rb_cObject);
5915 }
5916
5917 if (shareability != 0) {
5918 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
5919 }
5920 else {
5921 PM_COMPILE_NOT_POPPED(node->value);
5922 }
5923
5924 if (!popped) {
5925 PUSH_INSN(ret, location, swap);
5926 PUSH_INSN1(ret, location, topn, INT2FIX(1));
5927 }
5928
5929 PUSH_INSN(ret, location, swap);
5930 PUSH_INSN1(ret, location, setconstant, name);
5931}
5932
5937static void
5938pm_compile_constant_path_and_write_node(rb_iseq_t *iseq, const pm_constant_path_and_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5939{
5940 const pm_node_location_t location = *node_location;
5941 const pm_constant_path_node_t *target = node->target;
5942
5943 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5944 LABEL *lfin = NEW_LABEL(location.line);
5945
5946 if (target->parent) {
5947 PM_COMPILE_NOT_POPPED(target->parent);
5948 }
5949 else {
5950 PUSH_INSN1(ret, location, putobject, rb_cObject);
5951 }
5952
5953 PUSH_INSN(ret, location, dup);
5954 PUSH_INSN1(ret, location, putobject, Qtrue);
5955 PUSH_INSN1(ret, location, getconstant, name);
5956
5957 if (!popped) PUSH_INSN(ret, location, dup);
5958 PUSH_INSNL(ret, location, branchunless, lfin);
5959
5960 if (!popped) PUSH_INSN(ret, location, pop);
5961
5962 if (shareability != 0) {
5963 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
5964 }
5965 else {
5966 PM_COMPILE_NOT_POPPED(node->value);
5967 }
5968
5969 if (popped) {
5970 PUSH_INSN1(ret, location, topn, INT2FIX(1));
5971 }
5972 else {
5973 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
5974 PUSH_INSN(ret, location, swap);
5975 }
5976
5977 PUSH_INSN1(ret, location, setconstant, name);
5978 PUSH_LABEL(ret, lfin);
5979
5980 if (!popped) PUSH_INSN(ret, location, swap);
5981 PUSH_INSN(ret, location, pop);
5982}
5983
5988static void
5989pm_compile_constant_path_or_write_node(rb_iseq_t *iseq, const pm_constant_path_or_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
5990{
5991 const pm_node_location_t location = *node_location;
5992 const pm_constant_path_node_t *target = node->target;
5993
5994 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5995 LABEL *lassign = NEW_LABEL(location.line);
5996 LABEL *lfin = NEW_LABEL(location.line);
5997
5998 if (target->parent) {
5999 PM_COMPILE_NOT_POPPED(target->parent);
6000 }
6001 else {
6002 PUSH_INSN1(ret, location, putobject, rb_cObject);
6003 }
6004
6005 PUSH_INSN(ret, location, dup);
6006 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST_FROM), name, Qtrue);
6007 PUSH_INSNL(ret, location, branchunless, lassign);
6008
6009 PUSH_INSN(ret, location, dup);
6010 PUSH_INSN1(ret, location, putobject, Qtrue);
6011 PUSH_INSN1(ret, location, getconstant, name);
6012
6013 if (!popped) PUSH_INSN(ret, location, dup);
6014 PUSH_INSNL(ret, location, branchif, lfin);
6015
6016 if (!popped) PUSH_INSN(ret, location, pop);
6017 PUSH_LABEL(ret, lassign);
6018
6019 if (shareability != 0) {
6020 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
6021 }
6022 else {
6023 PM_COMPILE_NOT_POPPED(node->value);
6024 }
6025
6026 if (popped) {
6027 PUSH_INSN1(ret, location, topn, INT2FIX(1));
6028 }
6029 else {
6030 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
6031 PUSH_INSN(ret, location, swap);
6032 }
6033
6034 PUSH_INSN1(ret, location, setconstant, name);
6035 PUSH_LABEL(ret, lfin);
6036
6037 if (!popped) PUSH_INSN(ret, location, swap);
6038 PUSH_INSN(ret, location, pop);
6039}
6040
6045static void
6046pm_compile_constant_path_operator_write_node(rb_iseq_t *iseq, const pm_constant_path_operator_write_node_t *node, const pm_node_flags_t shareability, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
6047{
6048 const pm_node_location_t location = *node_location;
6049 const pm_constant_path_node_t *target = node->target;
6050
6051 ID method_id = pm_constant_id_lookup(scope_node, node->binary_operator);
6052 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
6053
6054 if (target->parent) {
6055 PM_COMPILE_NOT_POPPED(target->parent);
6056 }
6057 else {
6058 PUSH_INSN1(ret, location, putobject, rb_cObject);
6059 }
6060
6061 PUSH_INSN(ret, location, dup);
6062 PUSH_INSN1(ret, location, putobject, Qtrue);
6063 PUSH_INSN1(ret, location, getconstant, name);
6064
6065 if (shareability != 0) {
6066 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
6067 }
6068 else {
6069 PM_COMPILE_NOT_POPPED(node->value);
6070 }
6071
6072 PUSH_CALL(ret, location, method_id, INT2FIX(1));
6073 PUSH_INSN(ret, location, swap);
6074
6075 if (!popped) {
6076 PUSH_INSN1(ret, location, topn, INT2FIX(1));
6077 PUSH_INSN(ret, location, swap);
6078 }
6079
6080 PUSH_INSN1(ret, location, setconstant, name);
6081}
6082
6089#define PM_CONTAINER_P(node) (PM_NODE_TYPE_P(node, PM_ARRAY_NODE) || PM_NODE_TYPE_P(node, PM_HASH_NODE) || PM_NODE_TYPE_P(node, PM_RANGE_NODE))
6090
6095static inline void
6096pm_compile_scope_node(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped)
6097{
6098 const pm_node_location_t location = *node_location;
6099 struct rb_iseq_constant_body *body = ISEQ_BODY(iseq);
6100
6101 pm_constant_id_list_t *locals = &scope_node->locals;
6102 pm_parameters_node_t *parameters_node = NULL;
6103 pm_node_list_t *keywords_list = NULL;
6104 pm_node_list_t *optionals_list = NULL;
6105 pm_node_list_t *posts_list = NULL;
6106 pm_node_list_t *requireds_list = NULL;
6107 pm_node_list_t *block_locals = NULL;
6108 bool trailing_comma = false;
6109
6110 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE) || PM_NODE_TYPE_P(scope_node->ast_node, PM_MODULE_NODE)) {
6111 PUSH_TRACE(ret, RUBY_EVENT_CLASS);
6112 }
6113
6114 if (scope_node->parameters != NULL) {
6115 switch (PM_NODE_TYPE(scope_node->parameters)) {
6116 case PM_BLOCK_PARAMETERS_NODE: {
6117 pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) scope_node->parameters;
6118 parameters_node = cast->parameters;
6119 block_locals = &cast->locals;
6120
6121 if (parameters_node) {
6122 if (parameters_node->rest && PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE)) {
6123 trailing_comma = true;
6124 }
6125 }
6126 break;
6127 }
6128 case PM_PARAMETERS_NODE: {
6129 parameters_node = (pm_parameters_node_t *) scope_node->parameters;
6130 break;
6131 }
6132 case PM_NUMBERED_PARAMETERS_NODE: {
6133 uint32_t maximum = ((const pm_numbered_parameters_node_t *) scope_node->parameters)->maximum;
6134 body->param.lead_num = maximum;
6135 body->param.flags.ambiguous_param0 = maximum == 1;
6136 break;
6137 }
6138 case PM_IT_PARAMETERS_NODE:
6139 body->param.lead_num = 1;
6140 body->param.flags.ambiguous_param0 = true;
6141 break;
6142 default:
6143 rb_bug("Unexpected node type for parameters: %s", pm_node_type_to_str(PM_NODE_TYPE(scope_node->parameters)));
6144 }
6145 }
6146
6147 struct rb_iseq_param_keyword *keyword = NULL;
6148
6149 if (parameters_node) {
6150 optionals_list = &parameters_node->optionals;
6151 requireds_list = &parameters_node->requireds;
6152 keywords_list = &parameters_node->keywords;
6153 posts_list = &parameters_node->posts;
6154 }
6155 else if (scope_node->parameters && (PM_NODE_TYPE_P(scope_node->parameters, PM_NUMBERED_PARAMETERS_NODE) || PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE))) {
6156 body->param.opt_num = 0;
6157 }
6158 else {
6159 body->param.lead_num = 0;
6160 body->param.opt_num = 0;
6161 }
6162
6163 //********STEP 1**********
6164 // Goal: calculate the table size for the locals, accounting for
6165 // hidden variables and multi target nodes
6166 size_t locals_size = locals->size;
6167
6168 // Index lookup table buffer size is only the number of the locals
6169 st_table *index_lookup_table = st_init_numtable();
6170
6171 int table_size = (int) locals_size;
6172
6173 // For nodes have a hidden iteration variable. We add that to the local
6174 // table size here.
6175 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) table_size++;
6176
6177 if (keywords_list && keywords_list->size) {
6178 table_size++;
6179 }
6180
6181 if (requireds_list) {
6182 for (size_t i = 0; i < requireds_list->size; i++) {
6183 // For each MultiTargetNode, we're going to have one
6184 // additional anonymous local not represented in the locals table
6185 // We want to account for this in our table size
6186 pm_node_t *required = requireds_list->nodes[i];
6187 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6188 table_size++;
6189 }
6190 else if (PM_NODE_TYPE_P(required, PM_REQUIRED_PARAMETER_NODE)) {
6191 if (PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6192 table_size++;
6193 }
6194 }
6195 }
6196 }
6197
6198 // If we have the `it` implicit local variable, we need to account for
6199 // it in the local table size.
6200 if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
6201 table_size++;
6202 }
6203
6204 // Ensure there is enough room in the local table for any
6205 // parameters that have been repeated
6206 // ex: def underscore_parameters(_, _ = 1, _ = 2); _; end
6207 // ^^^^^^^^^^^^
6208 if (optionals_list && optionals_list->size) {
6209 for (size_t i = 0; i < optionals_list->size; i++) {
6210 pm_node_t * node = optionals_list->nodes[i];
6211 if (PM_NODE_FLAG_P(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6212 table_size++;
6213 }
6214 }
6215 }
6216
6217 // If we have an anonymous "rest" node, we'll need to increase the local
6218 // table size to take it in to account.
6219 // def m(foo, *, bar)
6220 // ^
6221 if (parameters_node) {
6222 if (parameters_node->rest) {
6223 if (!(PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE))) {
6224 if (!((const pm_rest_parameter_node_t *) parameters_node->rest)->name || PM_NODE_FLAG_P(parameters_node->rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6225 table_size++;
6226 }
6227 }
6228 }
6229
6230 // def foo(_, **_); _; end
6231 // ^^^
6232 if (parameters_node->keyword_rest) {
6233 // def foo(...); end
6234 // ^^^
6235 // When we have a `...` as the keyword_rest, it's a forwarding_parameter_node and
6236 // we need to leave space for 4 locals: *, **, &, ...
6237 if (PM_NODE_TYPE_P(parameters_node->keyword_rest, PM_FORWARDING_PARAMETER_NODE)) {
6238 // Only optimize specifically methods like this: `foo(...)`
6239 if (requireds_list->size == 0 && optionals_list->size == 0 && keywords_list->size == 0) {
6240 ISEQ_BODY(iseq)->param.flags.use_block = TRUE;
6241 ISEQ_BODY(iseq)->param.flags.forwardable = TRUE;
6242 table_size += 1;
6243 }
6244 else {
6245 table_size += 4;
6246 }
6247 }
6248 else {
6249 const pm_keyword_rest_parameter_node_t *kw_rest = (const pm_keyword_rest_parameter_node_t *) parameters_node->keyword_rest;
6250
6251 // If it's anonymous or repeated, then we need to allocate stack space
6252 if (!kw_rest->name || PM_NODE_FLAG_P(kw_rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6253 table_size++;
6254 }
6255 }
6256 }
6257 }
6258
6259 if (posts_list) {
6260 for (size_t i = 0; i < posts_list->size; i++) {
6261 // For each MultiTargetNode, we're going to have one
6262 // additional anonymous local not represented in the locals table
6263 // We want to account for this in our table size
6264 pm_node_t *required = posts_list->nodes[i];
6265 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE) || PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6266 table_size++;
6267 }
6268 }
6269 }
6270
6271 if (keywords_list && keywords_list->size) {
6272 for (size_t i = 0; i < keywords_list->size; i++) {
6273 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6274 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6275 table_size++;
6276 }
6277 }
6278 }
6279
6280 if (parameters_node && parameters_node->block) {
6281 const pm_block_parameter_node_t *block_node = (const pm_block_parameter_node_t *) parameters_node->block;
6282
6283 if (PM_NODE_FLAG_P(block_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER) || !block_node->name) {
6284 table_size++;
6285 }
6286 }
6287
6288 // We can create local_table_for_iseq with the correct size
6289 VALUE idtmp = 0;
6290 rb_ast_id_table_t *local_table_for_iseq = ALLOCV(idtmp, sizeof(rb_ast_id_table_t) + table_size * sizeof(ID));
6291 local_table_for_iseq->size = table_size;
6292
6293 //********END OF STEP 1**********
6294
6295 //********STEP 2**********
6296 // Goal: populate iv index table as well as local table, keeping the
6297 // layout of the local table consistent with the layout of the
6298 // stack when calling the method
6299 //
6300 // Do a first pass on all of the parameters, setting their values in
6301 // the local_table_for_iseq, _except_ for Multis who get a hidden
6302 // variable in this step, and will get their names inserted in step 3
6303
6304 // local_index is a cursor that keeps track of the current
6305 // index into local_table_for_iseq. The local table is actually a list,
6306 // and the order of that list must match the order of the items pushed
6307 // on the stack. We need to take in to account things pushed on the
6308 // stack that _might not have a name_ (for example array destructuring).
6309 // This index helps us know which item we're dealing with and also give
6310 // those anonymous items temporary names (as below)
6311 int local_index = 0;
6312
6313 // Here we figure out local table indices and insert them in to the
6314 // index lookup table and local tables.
6315 //
6316 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6317 // ^^^^^^^^^^^^^
6318 if (requireds_list && requireds_list->size) {
6319 for (size_t i = 0; i < requireds_list->size; i++, local_index++) {
6320 ID local;
6321
6322 // For each MultiTargetNode, we're going to have one additional
6323 // anonymous local not represented in the locals table. We want
6324 // to account for this in our table size.
6325 pm_node_t *required = requireds_list->nodes[i];
6326
6327 switch (PM_NODE_TYPE(required)) {
6328 case PM_MULTI_TARGET_NODE: {
6329 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6330 // ^^^^^^^^^^
6331 local = rb_make_temporary_id(local_index);
6332 local_table_for_iseq->ids[local_index] = local;
6333 break;
6334 }
6335 case PM_REQUIRED_PARAMETER_NODE: {
6336 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6337 // ^
6338 const pm_required_parameter_node_t *param = (const pm_required_parameter_node_t *) required;
6339
6340 if (PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6341 ID local = pm_constant_id_lookup(scope_node, param->name);
6342 local_table_for_iseq->ids[local_index] = local;
6343 }
6344 else {
6345 pm_insert_local_index(param->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6346 }
6347
6348 break;
6349 }
6350 default:
6351 rb_bug("Unsupported node in requireds in parameters %s", pm_node_type_to_str(PM_NODE_TYPE(required)));
6352 }
6353 }
6354
6355 body->param.lead_num = (int) requireds_list->size;
6356 body->param.flags.has_lead = true;
6357 }
6358
6359 if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
6360 ID local = rb_make_temporary_id(local_index);
6361 local_table_for_iseq->ids[local_index++] = local;
6362 }
6363
6364 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6365 // ^^^^^
6366 if (optionals_list && optionals_list->size) {
6367 body->param.opt_num = (int) optionals_list->size;
6368 body->param.flags.has_opt = true;
6369
6370 for (size_t i = 0; i < optionals_list->size; i++, local_index++) {
6371 pm_node_t * node = optionals_list->nodes[i];
6372 pm_constant_id_t name = ((const pm_optional_parameter_node_t *) node)->name;
6373
6374 if (PM_NODE_FLAG_P(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6375 ID local = pm_constant_id_lookup(scope_node, name);
6376 local_table_for_iseq->ids[local_index] = local;
6377 }
6378 else {
6379 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6380 }
6381 }
6382 }
6383
6384 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6385 // ^^
6386 if (parameters_node && parameters_node->rest) {
6387 body->param.rest_start = local_index;
6388
6389 // If there's a trailing comma, we'll have an implicit rest node,
6390 // and we don't want it to impact the rest variables on param
6391 if (!(PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE))) {
6392 body->param.flags.has_rest = true;
6393 RUBY_ASSERT(body->param.rest_start != -1);
6394
6395 pm_constant_id_t name = ((const pm_rest_parameter_node_t *) parameters_node->rest)->name;
6396
6397 if (name) {
6398 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6399 // ^^
6400 if (PM_NODE_FLAG_P(parameters_node->rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6401 ID local = pm_constant_id_lookup(scope_node, name);
6402 local_table_for_iseq->ids[local_index] = local;
6403 }
6404 else {
6405 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6406 }
6407 }
6408 else {
6409 // def foo(a, (b, *c, d), e = 1, *, g, (h, *i, j), k:, l: 1, **m, &n)
6410 // ^
6411 body->param.flags.anon_rest = true;
6412 pm_insert_local_special(idMULT, local_index, index_lookup_table, local_table_for_iseq);
6413 }
6414
6415 local_index++;
6416 }
6417 }
6418
6419 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6420 // ^^^^^^^^^^^^^
6421 if (posts_list && posts_list->size) {
6422 body->param.post_num = (int) posts_list->size;
6423 body->param.post_start = local_index;
6424 body->param.flags.has_post = true;
6425
6426 for (size_t i = 0; i < posts_list->size; i++, local_index++) {
6427 ID local;
6428
6429 // For each MultiTargetNode, we're going to have one additional
6430 // anonymous local not represented in the locals table. We want
6431 // to account for this in our table size.
6432 const pm_node_t *post_node = posts_list->nodes[i];
6433
6434 switch (PM_NODE_TYPE(post_node)) {
6435 case PM_MULTI_TARGET_NODE: {
6436 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6437 // ^^^^^^^^^^
6438 local = rb_make_temporary_id(local_index);
6439 local_table_for_iseq->ids[local_index] = local;
6440 break;
6441 }
6442 case PM_REQUIRED_PARAMETER_NODE: {
6443 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6444 // ^
6445 const pm_required_parameter_node_t *param = (const pm_required_parameter_node_t *) post_node;
6446
6447 if (PM_NODE_FLAG_P(param, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6448 ID local = pm_constant_id_lookup(scope_node, param->name);
6449 local_table_for_iseq->ids[local_index] = local;
6450 }
6451 else {
6452 pm_insert_local_index(param->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6453 }
6454 break;
6455 }
6456 default:
6457 rb_bug("Unsupported node in posts in parameters %s", pm_node_type_to_str(PM_NODE_TYPE(post_node)));
6458 }
6459 }
6460 }
6461
6462 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6463 // ^^^^^^^^
6464 // Keywords create an internal variable on the parse tree
6465 if (keywords_list && keywords_list->size) {
6466 keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6467 keyword->num = (int) keywords_list->size;
6468
6469 const VALUE default_values = rb_ary_hidden_new(1);
6470 const VALUE complex_mark = rb_str_tmp_new(0);
6471
6472 for (size_t i = 0; i < keywords_list->size; i++) {
6473 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6474 pm_constant_id_t name;
6475
6476 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6477 // ^^
6478 if (PM_NODE_TYPE_P(keyword_parameter_node, PM_REQUIRED_KEYWORD_PARAMETER_NODE)) {
6479 name = ((const pm_required_keyword_parameter_node_t *) keyword_parameter_node)->name;
6480 keyword->required_num++;
6481 ID local = pm_constant_id_lookup(scope_node, name);
6482
6483 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6484 local_table_for_iseq->ids[local_index] = local;
6485 }
6486 else {
6487 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6488 }
6489 local_index++;
6490 }
6491 }
6492
6493 for (size_t i = 0; i < keywords_list->size; i++) {
6494 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6495 pm_constant_id_t name;
6496
6497 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6498 // ^^^^
6499 if (PM_NODE_TYPE_P(keyword_parameter_node, PM_OPTIONAL_KEYWORD_PARAMETER_NODE)) {
6500 const pm_optional_keyword_parameter_node_t *cast = ((const pm_optional_keyword_parameter_node_t *) keyword_parameter_node);
6501
6502 pm_node_t *value = cast->value;
6503 name = cast->name;
6504
6505 if (PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) && !PM_CONTAINER_P(value)) {
6506 rb_ary_push(default_values, pm_static_literal_value(iseq, value, scope_node));
6507 }
6508 else {
6509 rb_ary_push(default_values, complex_mark);
6510 }
6511
6512 ID local = pm_constant_id_lookup(scope_node, name);
6513 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6514 local_table_for_iseq->ids[local_index] = local;
6515 }
6516 else {
6517 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6518 }
6519 local_index++;
6520 }
6521
6522 }
6523
6524 if (RARRAY_LEN(default_values)) {
6525 VALUE *dvs = ALLOC_N(VALUE, RARRAY_LEN(default_values));
6526
6527 for (int i = 0; i < RARRAY_LEN(default_values); i++) {
6528 VALUE dv = RARRAY_AREF(default_values, i);
6529 if (dv == complex_mark) dv = Qundef;
6530 RB_OBJ_WRITE(iseq, &dvs[i], dv);
6531 }
6532
6533 keyword->default_values = dvs;
6534 }
6535
6536 // Hidden local for keyword arguments
6537 keyword->bits_start = local_index;
6538 ID local = rb_make_temporary_id(local_index);
6539 local_table_for_iseq->ids[local_index] = local;
6540 local_index++;
6541
6542 body->param.keyword = keyword;
6543 body->param.flags.has_kw = true;
6544 }
6545
6546 if (body->type == ISEQ_TYPE_BLOCK && local_index == 1 && requireds_list && requireds_list->size == 1 && !trailing_comma) {
6547 body->param.flags.ambiguous_param0 = true;
6548 }
6549
6550 if (parameters_node) {
6551 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6552 // ^^^
6553 if (parameters_node->keyword_rest) {
6554 switch (PM_NODE_TYPE(parameters_node->keyword_rest)) {
6555 case PM_NO_KEYWORDS_PARAMETER_NODE: {
6556 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **nil, &n)
6557 // ^^^^^
6558 body->param.flags.accepts_no_kwarg = true;
6559 break;
6560 }
6561 case PM_KEYWORD_REST_PARAMETER_NODE: {
6562 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6563 // ^^^
6564 const pm_keyword_rest_parameter_node_t *kw_rest_node = (const pm_keyword_rest_parameter_node_t *) parameters_node->keyword_rest;
6565 if (!body->param.flags.has_kw) {
6566 body->param.keyword = keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6567 }
6568
6569 keyword->rest_start = local_index;
6570 body->param.flags.has_kwrest = true;
6571
6572 pm_constant_id_t constant_id = kw_rest_node->name;
6573 if (constant_id) {
6574 if (PM_NODE_FLAG_P(kw_rest_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6575 ID local = pm_constant_id_lookup(scope_node, constant_id);
6576 local_table_for_iseq->ids[local_index] = local;
6577 }
6578 else {
6579 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6580 }
6581 }
6582 else {
6583 body->param.flags.anon_kwrest = true;
6584 pm_insert_local_special(idPow, local_index, index_lookup_table, local_table_for_iseq);
6585 }
6586
6587 local_index++;
6588 break;
6589 }
6590 case PM_FORWARDING_PARAMETER_NODE: {
6591 // def foo(...)
6592 // ^^^
6593 if (!ISEQ_BODY(iseq)->param.flags.forwardable) {
6594 // Add the anonymous *
6595 body->param.rest_start = local_index;
6596 body->param.flags.has_rest = true;
6597 body->param.flags.anon_rest = true;
6598 pm_insert_local_special(idMULT, local_index++, index_lookup_table, local_table_for_iseq);
6599
6600 // Add the anonymous **
6601 RUBY_ASSERT(!body->param.flags.has_kw);
6602 body->param.flags.has_kw = false;
6603 body->param.flags.has_kwrest = true;
6604 body->param.flags.anon_kwrest = true;
6605 body->param.keyword = keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6606 keyword->rest_start = local_index;
6607 pm_insert_local_special(idPow, local_index++, index_lookup_table, local_table_for_iseq);
6608
6609 // Add the anonymous &
6610 body->param.block_start = local_index;
6611 body->param.flags.has_block = true;
6612 pm_insert_local_special(idAnd, local_index++, index_lookup_table, local_table_for_iseq);
6613 }
6614
6615 // Add the ...
6616 pm_insert_local_special(idDot3, local_index++, index_lookup_table, local_table_for_iseq);
6617 break;
6618 }
6619 default:
6620 rb_bug("node type %s not expected as keyword_rest", pm_node_type_to_str(PM_NODE_TYPE(parameters_node->keyword_rest)));
6621 }
6622 }
6623
6624 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6625 // ^^
6626 if (parameters_node->block) {
6627 body->param.block_start = local_index;
6628 body->param.flags.has_block = true;
6629 iseq_set_use_block(iseq);
6630
6631 pm_constant_id_t name = ((const pm_block_parameter_node_t *) parameters_node->block)->name;
6632
6633 if (name) {
6634 if (PM_NODE_FLAG_P(parameters_node->block, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6635 ID local = pm_constant_id_lookup(scope_node, name);
6636 local_table_for_iseq->ids[local_index] = local;
6637 }
6638 else {
6639 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6640 }
6641 }
6642 else {
6643 pm_insert_local_special(idAnd, local_index, index_lookup_table, local_table_for_iseq);
6644 }
6645
6646 local_index++;
6647 }
6648 }
6649
6650 //********END OF STEP 2**********
6651 // The local table is now consistent with expected
6652 // stack layout
6653
6654 // If there's only one required element in the parameters
6655 // CRuby needs to recognize it as an ambiguous parameter
6656
6657 //********STEP 3**********
6658 // Goal: fill in the names of the parameters in MultiTargetNodes
6659 //
6660 // Go through requireds again to set the multis
6661
6662 if (requireds_list && requireds_list->size) {
6663 for (size_t i = 0; i < requireds_list->size; i++) {
6664 // For each MultiTargetNode, we're going to have one
6665 // additional anonymous local not represented in the locals table
6666 // We want to account for this in our table size
6667 const pm_node_t *required = requireds_list->nodes[i];
6668
6669 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6670 local_index = pm_compile_destructured_param_locals((const pm_multi_target_node_t *) required, index_lookup_table, local_table_for_iseq, scope_node, local_index);
6671 }
6672 }
6673 }
6674
6675 // Go through posts again to set the multis
6676 if (posts_list && posts_list->size) {
6677 for (size_t i = 0; i < posts_list->size; i++) {
6678 // For each MultiTargetNode, we're going to have one
6679 // additional anonymous local not represented in the locals table
6680 // We want to account for this in our table size
6681 const pm_node_t *post = posts_list->nodes[i];
6682
6683 if (PM_NODE_TYPE_P(post, PM_MULTI_TARGET_NODE)) {
6684 local_index = pm_compile_destructured_param_locals((const pm_multi_target_node_t *) post, index_lookup_table, local_table_for_iseq, scope_node, local_index);
6685 }
6686 }
6687 }
6688
6689 // Set any anonymous locals for the for node
6690 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) {
6691 if (PM_NODE_TYPE_P(((const pm_for_node_t *) scope_node->ast_node)->index, PM_LOCAL_VARIABLE_TARGET_NODE)) {
6692 body->param.lead_num++;
6693 }
6694 else {
6695 body->param.rest_start = local_index;
6696 body->param.flags.has_rest = true;
6697 }
6698
6699 ID local = rb_make_temporary_id(local_index);
6700 local_table_for_iseq->ids[local_index] = local;
6701 local_index++;
6702 }
6703
6704 // Fill in any NumberedParameters, if they exist
6705 if (scope_node->parameters && PM_NODE_TYPE_P(scope_node->parameters, PM_NUMBERED_PARAMETERS_NODE)) {
6706 int maximum = ((const pm_numbered_parameters_node_t *) scope_node->parameters)->maximum;
6707 RUBY_ASSERT(0 < maximum && maximum <= 9);
6708 for (int i = 0; i < maximum; i++, local_index++) {
6709 const uint8_t param_name[] = { '_', '1' + i };
6710 pm_constant_id_t constant_id = pm_constant_pool_find(&scope_node->parser->constant_pool, param_name, 2);
6711 RUBY_ASSERT(constant_id && "parser should fill in any gaps in numbered parameters");
6712 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6713 }
6714 body->param.lead_num = maximum;
6715 body->param.flags.has_lead = true;
6716 }
6717
6718 //********END OF STEP 3**********
6719
6720 //********STEP 4**********
6721 // Goal: fill in the method body locals
6722 // To be explicit, these are the non-parameter locals
6723 // We fill in the block_locals, if they exist
6724 // lambda { |x; y| y }
6725 // ^
6726 if (block_locals && block_locals->size) {
6727 for (size_t i = 0; i < block_locals->size; i++, local_index++) {
6728 pm_constant_id_t constant_id = ((const pm_block_local_variable_node_t *) block_locals->nodes[i])->name;
6729 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6730 }
6731 }
6732
6733 // Fill in any locals we missed
6734 if (scope_node->locals.size) {
6735 for (size_t i = 0; i < scope_node->locals.size; i++) {
6736 pm_constant_id_t constant_id = locals->ids[i];
6737 if (constant_id) {
6738 struct pm_local_table_insert_ctx ctx;
6739 ctx.scope_node = scope_node;
6740 ctx.local_table_for_iseq = local_table_for_iseq;
6741 ctx.local_index = local_index;
6742
6743 st_update(index_lookup_table, (st_data_t)constant_id, pm_local_table_insert_func, (st_data_t)&ctx);
6744
6745 local_index = ctx.local_index;
6746 }
6747 }
6748 }
6749
6750 //********END OF STEP 4**********
6751
6752 // We set the index_lookup_table on the scope node so we can
6753 // refer to the parameters correctly
6754 if (scope_node->index_lookup_table) {
6755 st_free_table(scope_node->index_lookup_table);
6756 }
6757 scope_node->index_lookup_table = index_lookup_table;
6758 iseq_calc_param_size(iseq);
6759
6760 if (ISEQ_BODY(iseq)->param.flags.forwardable) {
6761 // We're treating `...` as a parameter so that frame
6762 // pushing won't clobber it.
6763 ISEQ_BODY(iseq)->param.size += 1;
6764 }
6765
6766 // FIXME: args?
6767 iseq_set_local_table(iseq, local_table_for_iseq, 0);
6768 scope_node->local_table_for_iseq_size = local_table_for_iseq->size;
6769
6770 if (keyword != NULL) {
6771 size_t keyword_start_index = keyword->bits_start - keyword->num;
6772 keyword->table = (ID *)&ISEQ_BODY(iseq)->local_table[keyword_start_index];
6773 }
6774
6775 //********STEP 5************
6776 // Goal: compile anything that needed to be compiled
6777 if (optionals_list && optionals_list->size) {
6778 LABEL **opt_table = (LABEL **) ALLOC_N(VALUE, optionals_list->size + 1);
6779 LABEL *label;
6780
6781 // TODO: Should we make an api for NEW_LABEL where you can pass
6782 // a pointer to the label it should fill out? We already
6783 // have a list of labels allocated above so it seems wasteful
6784 // to do the copies.
6785 for (size_t i = 0; i < optionals_list->size; i++) {
6786 label = NEW_LABEL(location.line);
6787 opt_table[i] = label;
6788 PUSH_LABEL(ret, label);
6789 pm_node_t *optional_node = optionals_list->nodes[i];
6790 PM_COMPILE_NOT_POPPED(optional_node);
6791 }
6792
6793 // Set the last label
6794 label = NEW_LABEL(location.line);
6795 opt_table[optionals_list->size] = label;
6796 PUSH_LABEL(ret, label);
6797
6798 body->param.opt_table = (const VALUE *) opt_table;
6799 }
6800
6801 if (keywords_list && keywords_list->size) {
6802 size_t optional_index = 0;
6803 for (size_t i = 0; i < keywords_list->size; i++) {
6804 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6805 pm_constant_id_t name;
6806
6807 switch (PM_NODE_TYPE(keyword_parameter_node)) {
6808 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
6809 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6810 // ^^^^
6811 const pm_optional_keyword_parameter_node_t *cast = ((const pm_optional_keyword_parameter_node_t *) keyword_parameter_node);
6812
6813 pm_node_t *value = cast->value;
6814 name = cast->name;
6815
6816 if (!PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) || PM_CONTAINER_P(value)) {
6817 LABEL *end_label = NEW_LABEL(location.line);
6818
6819 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, name, 0);
6820 int kw_bits_idx = table_size - body->param.keyword->bits_start;
6821 PUSH_INSN2(ret, location, checkkeyword, INT2FIX(kw_bits_idx + VM_ENV_DATA_SIZE - 1), INT2FIX(optional_index));
6822 PUSH_INSNL(ret, location, branchif, end_label);
6823 PM_COMPILE(value);
6824 PUSH_SETLOCAL(ret, location, index.index, index.level);
6825 PUSH_LABEL(ret, end_label);
6826 }
6827 optional_index++;
6828 break;
6829 }
6830 case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
6831 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6832 // ^^
6833 break;
6834 default:
6835 rb_bug("Unexpected keyword parameter node type %s", pm_node_type_to_str(PM_NODE_TYPE(keyword_parameter_node)));
6836 }
6837 }
6838 }
6839
6840 if (requireds_list && requireds_list->size) {
6841 for (size_t i = 0; i < requireds_list->size; i++) {
6842 // For each MultiTargetNode, we're going to have one additional
6843 // anonymous local not represented in the locals table. We want
6844 // to account for this in our table size.
6845 const pm_node_t *required = requireds_list->nodes[i];
6846
6847 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6848 PUSH_GETLOCAL(ret, location, table_size - (int)i, 0);
6849 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) required, ret, scope_node);
6850 }
6851 }
6852 }
6853
6854 if (posts_list && posts_list->size) {
6855 for (size_t i = 0; i < posts_list->size; i++) {
6856 // For each MultiTargetNode, we're going to have one additional
6857 // anonymous local not represented in the locals table. We want
6858 // to account for this in our table size.
6859 const pm_node_t *post = posts_list->nodes[i];
6860
6861 if (PM_NODE_TYPE_P(post, PM_MULTI_TARGET_NODE)) {
6862 PUSH_GETLOCAL(ret, location, table_size - body->param.post_start - (int) i, 0);
6863 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) post, ret, scope_node);
6864 }
6865 }
6866 }
6867
6868 switch (body->type) {
6869 case ISEQ_TYPE_PLAIN: {
6870 RUBY_ASSERT(PM_NODE_TYPE_P(scope_node->ast_node, PM_INTERPOLATED_REGULAR_EXPRESSION_NODE));
6871
6872 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) scope_node->ast_node;
6873 pm_compile_regexp_dynamic(iseq, (const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6874
6875 break;
6876 }
6877 case ISEQ_TYPE_BLOCK: {
6878 LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
6879 LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
6880 const pm_node_location_t block_location = { .line = body->location.first_lineno, .node_id = scope_node->ast_node->node_id };
6881
6882 start->rescued = LABEL_RESCUE_BEG;
6883 end->rescued = LABEL_RESCUE_END;
6884
6885 // For nodes automatically assign the iteration variable to whatever
6886 // index variable. We need to handle that write here because it has
6887 // to happen in the context of the block. Note that this happens
6888 // before the B_CALL tracepoint event.
6889 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) {
6890 pm_compile_for_node_index(iseq, ((const pm_for_node_t *) scope_node->ast_node)->index, ret, scope_node);
6891 }
6892
6893 PUSH_TRACE(ret, RUBY_EVENT_B_CALL);
6894 PUSH_INSN(ret, block_location, nop);
6895 PUSH_LABEL(ret, start);
6896
6897 if (scope_node->body != NULL) {
6898 switch (PM_NODE_TYPE(scope_node->ast_node)) {
6899 case PM_POST_EXECUTION_NODE: {
6900 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) scope_node->ast_node;
6901 PUSH_INSN1(ret, block_location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6902
6903 // We create another ScopeNode from the statements within the PostExecutionNode
6904 pm_scope_node_t next_scope_node;
6905 pm_scope_node_init((const pm_node_t *) cast->statements, &next_scope_node, scope_node);
6906
6907 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(body->parent_iseq), ISEQ_TYPE_BLOCK, location.line);
6908 pm_scope_node_destroy(&next_scope_node);
6909
6910 PUSH_CALL_WITH_BLOCK(ret, block_location, id_core_set_postexe, INT2FIX(0), block);
6911 break;
6912 }
6913 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
6914 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) scope_node->ast_node;
6915 pm_compile_regexp_dynamic(iseq, (const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6916 break;
6917 }
6918 default:
6919 pm_compile_node(iseq, scope_node->body, ret, popped, scope_node);
6920 break;
6921 }
6922 }
6923 else {
6924 PUSH_INSN(ret, block_location, putnil);
6925 }
6926
6927 PUSH_LABEL(ret, end);
6928 PUSH_TRACE(ret, RUBY_EVENT_B_RETURN);
6929 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6930
6931 /* wide range catch handler must put at last */
6932 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start);
6933 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end);
6934 break;
6935 }
6936 case ISEQ_TYPE_ENSURE: {
6937 const pm_node_location_t statements_location = (scope_node->body != NULL ? PM_NODE_START_LOCATION(scope_node->parser, scope_node->body) : location);
6938 iseq_set_exception_local_table(iseq);
6939
6940 if (scope_node->body != NULL) {
6941 PM_COMPILE_POPPED((const pm_node_t *) scope_node->body);
6942 }
6943
6944 PUSH_GETLOCAL(ret, statements_location, 1, 0);
6945 PUSH_INSN1(ret, statements_location, throw, INT2FIX(0));
6946 return;
6947 }
6948 case ISEQ_TYPE_METHOD: {
6949 ISEQ_COMPILE_DATA(iseq)->root_node = (const void *) scope_node->body;
6950 PUSH_TRACE(ret, RUBY_EVENT_CALL);
6951
6952 if (scope_node->body) {
6953 PM_COMPILE((const pm_node_t *) scope_node->body);
6954 }
6955 else {
6956 PUSH_INSN(ret, location, putnil);
6957 }
6958
6959 ISEQ_COMPILE_DATA(iseq)->root_node = (const void *) scope_node->body;
6960 PUSH_TRACE(ret, RUBY_EVENT_RETURN);
6961
6962 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6963 break;
6964 }
6965 case ISEQ_TYPE_RESCUE: {
6966 iseq_set_exception_local_table(iseq);
6967 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_RESCUE_MODIFIER_NODE)) {
6968 LABEL *lab = NEW_LABEL(location.line);
6969 LABEL *rescue_end = NEW_LABEL(location.line);
6970 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
6971 PUSH_INSN1(ret, location, putobject, rb_eStandardError);
6972 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
6973 PUSH_INSNL(ret, location, branchif, lab);
6974 PUSH_INSNL(ret, location, jump, rescue_end);
6975 PUSH_LABEL(ret, lab);
6976 PUSH_TRACE(ret, RUBY_EVENT_RESCUE);
6977 PM_COMPILE((const pm_node_t *) scope_node->body);
6978 PUSH_INSN(ret, location, leave);
6979 PUSH_LABEL(ret, rescue_end);
6980 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
6981 }
6982 else {
6983 PM_COMPILE((const pm_node_t *) scope_node->ast_node);
6984 }
6985 PUSH_INSN1(ret, location, throw, INT2FIX(0));
6986
6987 return;
6988 }
6989 default:
6990 if (scope_node->body) {
6991 PM_COMPILE((const pm_node_t *) scope_node->body);
6992 }
6993 else {
6994 PUSH_INSN(ret, location, putnil);
6995 }
6996 break;
6997 }
6998
6999 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE) || PM_NODE_TYPE_P(scope_node->ast_node, PM_MODULE_NODE)) {
7000 const pm_node_location_t end_location = PM_NODE_END_LOCATION(scope_node->parser, scope_node->ast_node);
7001 PUSH_TRACE(ret, RUBY_EVENT_END);
7002 ISEQ_COMPILE_DATA(iseq)->last_line = end_location.line;
7003 }
7004
7005 if (!PM_NODE_TYPE_P(scope_node->ast_node, PM_ENSURE_NODE)) {
7006 const pm_node_location_t location = { .line = ISEQ_COMPILE_DATA(iseq)->last_line, .node_id = scope_node->ast_node->node_id };
7007 PUSH_INSN(ret, location, leave);
7008 }
7009}
7010
7011static inline void
7012pm_compile_alias_global_variable_node(rb_iseq_t *iseq, const pm_alias_global_variable_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7013{
7014 // alias $foo $bar
7015 // ^^^^^^^^^^^^^^^
7016 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7017
7018 {
7019 const pm_location_t *name_loc = &node->new_name->location;
7020 VALUE operand = ID2SYM(rb_intern3((const char *) name_loc->start, name_loc->end - name_loc->start, scope_node->encoding));
7021 PUSH_INSN1(ret, *location, putobject, operand);
7022 }
7023
7024 {
7025 const pm_location_t *name_loc = &node->old_name->location;
7026 VALUE operand = ID2SYM(rb_intern3((const char *) name_loc->start, name_loc->end - name_loc->start, scope_node->encoding));
7027 PUSH_INSN1(ret, *location, putobject, operand);
7028 }
7029
7030 PUSH_SEND(ret, *location, id_core_set_variable_alias, INT2FIX(2));
7031 if (popped) PUSH_INSN(ret, *location, pop);
7032}
7033
7034static inline void
7035pm_compile_alias_method_node(rb_iseq_t *iseq, const pm_alias_method_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7036{
7037 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7038 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
7039 PM_COMPILE_NOT_POPPED(node->new_name);
7040 PM_COMPILE_NOT_POPPED(node->old_name);
7041
7042 PUSH_SEND(ret, *location, id_core_set_method_alias, INT2FIX(3));
7043 if (popped) PUSH_INSN(ret, *location, pop);
7044}
7045
7046static inline void
7047pm_compile_and_node(rb_iseq_t *iseq, const pm_and_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7048{
7049 LABEL *end_label = NEW_LABEL(location->line);
7050
7051 PM_COMPILE_NOT_POPPED(node->left);
7052 if (!popped) PUSH_INSN(ret, *location, dup);
7053 PUSH_INSNL(ret, *location, branchunless, end_label);
7054
7055 if (!popped) PUSH_INSN(ret, *location, pop);
7056 PM_COMPILE(node->right);
7057 PUSH_LABEL(ret, end_label);
7058}
7059
7060static inline void
7061pm_compile_array_node(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_list_t *elements, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7062{
7063 // If every node in the array is static, then we can compile the entire
7064 // array now instead of later.
7065 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
7066 // We're only going to compile this node if it's not popped. If it
7067 // is popped, then we know we don't need to do anything since it's
7068 // statically known.
7069 if (!popped) {
7070 if (elements->size) {
7071 VALUE value = pm_static_literal_value(iseq, node, scope_node);
7072 PUSH_INSN1(ret, *location, duparray, value);
7073 }
7074 else {
7075 PUSH_INSN1(ret, *location, newarray, INT2FIX(0));
7076 }
7077 }
7078 return;
7079 }
7080
7081 // Here since we know there are possible side-effects inside the
7082 // array contents, we're going to build it entirely at runtime.
7083 // We'll do this by pushing all of the elements onto the stack and
7084 // then combining them with newarray.
7085 //
7086 // If this array is popped, then this serves only to ensure we enact
7087 // all side-effects (like method calls) that are contained within
7088 // the array contents.
7089 //
7090 // We treat all sequences of non-splat elements as their
7091 // own arrays, followed by a newarray, and then continually
7092 // concat the arrays with the SplatNode nodes.
7093 const int max_new_array_size = 0x100;
7094 const unsigned int min_tmp_array_size = 0x40;
7095
7096 int new_array_size = 0;
7097 bool first_chunk = true;
7098
7099 // This is an optimization wherein we keep track of whether or not
7100 // the previous element was a static literal. If it was, then we do
7101 // not attempt to check if we have a subarray that can be optimized.
7102 // If it was not, then we do check.
7103 bool static_literal = false;
7104
7105 // Either create a new array, or push to the existing array.
7106#define FLUSH_CHUNK \
7107 if (new_array_size) { \
7108 if (first_chunk) PUSH_INSN1(ret, *location, newarray, INT2FIX(new_array_size)); \
7109 else PUSH_INSN1(ret, *location, pushtoarray, INT2FIX(new_array_size)); \
7110 first_chunk = false; \
7111 new_array_size = 0; \
7112 }
7113
7114 for (size_t index = 0; index < elements->size; index++) {
7115 const pm_node_t *element = elements->nodes[index];
7116
7117 if (PM_NODE_TYPE_P(element, PM_SPLAT_NODE)) {
7118 FLUSH_CHUNK;
7119
7120 const pm_splat_node_t *splat_element = (const pm_splat_node_t *) element;
7121 if (splat_element->expression) {
7122 PM_COMPILE_NOT_POPPED(splat_element->expression);
7123 }
7124 else {
7125 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
7126 PUSH_GETLOCAL(ret, *location, index.index, index.level);
7127 }
7128
7129 if (first_chunk) {
7130 // If this is the first element of the array then we
7131 // need to splatarray the elements into the list.
7132 PUSH_INSN1(ret, *location, splatarray, Qtrue);
7133 first_chunk = false;
7134 }
7135 else {
7136 PUSH_INSN(ret, *location, concattoarray);
7137 }
7138
7139 static_literal = false;
7140 }
7141 else if (PM_NODE_TYPE_P(element, PM_KEYWORD_HASH_NODE)) {
7142 if (new_array_size == 0 && first_chunk) {
7143 PUSH_INSN1(ret, *location, newarray, INT2FIX(0));
7144 first_chunk = false;
7145 }
7146 else {
7147 FLUSH_CHUNK;
7148 }
7149
7150 // If we get here, then this is the last element of the
7151 // array/arguments, because it cannot be followed by
7152 // anything else without a syntax error. This looks like:
7153 //
7154 // [foo, bar, baz: qux]
7155 // ^^^^^^^^
7156 //
7157 // [foo, bar, **baz]
7158 // ^^^^^
7159 //
7160 const pm_keyword_hash_node_t *keyword_hash = (const pm_keyword_hash_node_t *) element;
7161 pm_compile_hash_elements(iseq, element, &keyword_hash->elements, 0, Qundef, false, ret, scope_node);
7162
7163 // This boolean controls the manner in which we push the
7164 // hash onto the array. If it's all keyword splats, then we
7165 // can use the very specialized pushtoarraykwsplat
7166 // instruction to check if it's empty before we push it.
7167 size_t splats = 0;
7168 while (splats < keyword_hash->elements.size && PM_NODE_TYPE_P(keyword_hash->elements.nodes[splats], PM_ASSOC_SPLAT_NODE)) splats++;
7169
7170 if (keyword_hash->elements.size == splats) {
7171 PUSH_INSN(ret, *location, pushtoarraykwsplat);
7172 }
7173 else {
7174 new_array_size++;
7175 }
7176 }
7177 else if (
7178 PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL) &&
7179 !PM_CONTAINER_P(element) &&
7180 !static_literal &&
7181 ((index + min_tmp_array_size) < elements->size)
7182 ) {
7183 // If we have a static literal, then there's the potential
7184 // to group a bunch of them together with a literal array
7185 // and then concat them together.
7186 size_t right_index = index + 1;
7187 while (
7188 right_index < elements->size &&
7189 PM_NODE_FLAG_P(elements->nodes[right_index], PM_NODE_FLAG_STATIC_LITERAL) &&
7190 !PM_CONTAINER_P(elements->nodes[right_index])
7191 ) right_index++;
7192
7193 size_t tmp_array_size = right_index - index;
7194 if (tmp_array_size >= min_tmp_array_size) {
7195 VALUE tmp_array = rb_ary_hidden_new(tmp_array_size);
7196
7197 // Create the temporary array.
7198 for (; tmp_array_size; tmp_array_size--)
7199 rb_ary_push(tmp_array, pm_static_literal_value(iseq, elements->nodes[index++], scope_node));
7200
7201 index--; // about to be incremented by for loop
7202 OBJ_FREEZE(tmp_array);
7203
7204 // Emit the optimized code.
7205 FLUSH_CHUNK;
7206 if (first_chunk) {
7207 PUSH_INSN1(ret, *location, duparray, tmp_array);
7208 first_chunk = false;
7209 }
7210 else {
7211 PUSH_INSN1(ret, *location, putobject, tmp_array);
7212 PUSH_INSN(ret, *location, concattoarray);
7213 }
7214 }
7215 else {
7216 PM_COMPILE_NOT_POPPED(element);
7217 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7218 static_literal = true;
7219 }
7220 } else {
7221 PM_COMPILE_NOT_POPPED(element);
7222 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7223 static_literal = false;
7224 }
7225 }
7226
7227 FLUSH_CHUNK;
7228 if (popped) PUSH_INSN(ret, *location, pop);
7229
7230#undef FLUSH_CHUNK
7231}
7232
7233static inline void
7234pm_compile_break_node(rb_iseq_t *iseq, const pm_break_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7235{
7236 unsigned long throw_flag = 0;
7237
7238 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
7239 /* while/until */
7240 LABEL *splabel = NEW_LABEL(0);
7241 PUSH_LABEL(ret, splabel);
7242 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
7243
7244 if (node->arguments != NULL) {
7245 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
7246 }
7247 else {
7248 PUSH_INSN(ret, *location, putnil);
7249 }
7250
7251 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7252 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
7253 PUSH_ADJUST_RESTORE(ret, splabel);
7254 if (!popped) PUSH_INSN(ret, *location, putnil);
7255 }
7256 else {
7257 const rb_iseq_t *ip = iseq;
7258
7259 while (ip) {
7260 if (!ISEQ_COMPILE_DATA(ip)) {
7261 ip = 0;
7262 break;
7263 }
7264
7265 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
7266 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
7267 }
7268 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
7269 throw_flag = 0;
7270 }
7271 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
7272 COMPILE_ERROR(iseq, location->line, "Invalid break");
7273 return;
7274 }
7275 else {
7276 ip = ISEQ_BODY(ip)->parent_iseq;
7277 continue;
7278 }
7279
7280 /* escape from block */
7281 if (node->arguments != NULL) {
7282 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
7283 }
7284 else {
7285 PUSH_INSN(ret, *location, putnil);
7286 }
7287
7288 PUSH_INSN1(ret, *location, throw, INT2FIX(throw_flag | TAG_BREAK));
7289 if (popped) PUSH_INSN(ret, *location, pop);
7290
7291 return;
7292 }
7293
7294 COMPILE_ERROR(iseq, location->line, "Invalid break");
7295 }
7296}
7297
7298static inline void
7299pm_compile_call_node(rb_iseq_t *iseq, const pm_call_node_t *node, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7300{
7301 ID method_id = pm_constant_id_lookup(scope_node, node->name);
7302
7303 const pm_location_t *message_loc = &node->message_loc;
7304 if (message_loc->start == NULL) message_loc = &node->base.location;
7305
7306 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, message_loc, node->base.node_id);
7307 const char *builtin_func;
7308
7309 if (UNLIKELY(iseq_has_builtin_function_table(iseq)) && (builtin_func = pm_iseq_builtin_function_name(scope_node, node->receiver, method_id)) != NULL) {
7310 pm_compile_builtin_function_call(iseq, ret, scope_node, node, &location, popped, ISEQ_COMPILE_DATA(iseq)->current_block, builtin_func);
7311 return;
7312 }
7313
7314 LABEL *start = NEW_LABEL(location.line);
7315 if (node->block) PUSH_LABEL(ret, start);
7316
7317 switch (method_id) {
7318 case idUMinus: {
7319 if (pm_opt_str_freeze_p(iseq, node)) {
7320 VALUE value = parse_static_literal_string(iseq, scope_node, node->receiver, &((const pm_string_node_t * ) node->receiver)->unescaped);
7321 const struct rb_callinfo *callinfo = new_callinfo(iseq, idUMinus, 0, 0, NULL, FALSE);
7322 PUSH_INSN2(ret, location, opt_str_uminus, value, callinfo);
7323 if (popped) PUSH_INSN(ret, location, pop);
7324 return;
7325 }
7326 break;
7327 }
7328 case idFreeze: {
7329 if (pm_opt_str_freeze_p(iseq, node)) {
7330 VALUE value = parse_static_literal_string(iseq, scope_node, node->receiver, &((const pm_string_node_t * ) node->receiver)->unescaped);
7331 const struct rb_callinfo *callinfo = new_callinfo(iseq, idFreeze, 0, 0, NULL, FALSE);
7332 PUSH_INSN2(ret, location, opt_str_freeze, value, callinfo);
7333 if (popped) PUSH_INSN(ret, location, pop);
7334 return;
7335 }
7336 break;
7337 }
7338 case idAREF: {
7339 if (pm_opt_aref_with_p(iseq, node)) {
7340 const pm_string_node_t *string = (const pm_string_node_t *) ((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0];
7341 VALUE value = parse_static_literal_string(iseq, scope_node, (const pm_node_t *) string, &string->unescaped);
7342
7343 PM_COMPILE_NOT_POPPED(node->receiver);
7344
7345 const struct rb_callinfo *callinfo = new_callinfo(iseq, idAREF, 1, 0, NULL, FALSE);
7346 PUSH_INSN2(ret, location, opt_aref_with, value, callinfo);
7347
7348 if (popped) {
7349 PUSH_INSN(ret, location, pop);
7350 }
7351
7352 return;
7353 }
7354 break;
7355 }
7356 case idASET: {
7357 if (pm_opt_aset_with_p(iseq, node)) {
7358 const pm_string_node_t *string = (const pm_string_node_t *) ((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0];
7359 VALUE value = parse_static_literal_string(iseq, scope_node, (const pm_node_t *) string, &string->unescaped);
7360
7361 PM_COMPILE_NOT_POPPED(node->receiver);
7362 PM_COMPILE_NOT_POPPED(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[1]);
7363
7364 if (!popped) {
7365 PUSH_INSN(ret, location, swap);
7366 PUSH_INSN1(ret, location, topn, INT2FIX(1));
7367 }
7368
7369 const struct rb_callinfo *callinfo = new_callinfo(iseq, idASET, 2, 0, NULL, FALSE);
7370 PUSH_INSN2(ret, location, opt_aset_with, value, callinfo);
7371 PUSH_INSN(ret, location, pop);
7372 return;
7373 }
7374 break;
7375 }
7376 }
7377
7378 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) && !popped) {
7379 PUSH_INSN(ret, location, putnil);
7380 }
7381
7382 if (node->receiver == NULL) {
7383 PUSH_INSN(ret, location, putself);
7384 }
7385 else {
7386 if (method_id == idCall && PM_NODE_TYPE_P(node->receiver, PM_LOCAL_VARIABLE_READ_NODE)) {
7387 const pm_local_variable_read_node_t *read_node_cast = (const pm_local_variable_read_node_t *) node->receiver;
7388 uint32_t node_id = node->receiver->node_id;
7389 int idx, level;
7390
7391 if (iseq_block_param_id_p(iseq, pm_constant_id_lookup(scope_node, read_node_cast->name), &idx, &level)) {
7392 ADD_ELEM(ret, (LINK_ELEMENT *) new_insn_body(iseq, location.line, node_id, BIN(getblockparamproxy), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
7393 }
7394 else {
7395 PM_COMPILE_NOT_POPPED(node->receiver);
7396 }
7397 }
7398 else {
7399 PM_COMPILE_NOT_POPPED(node->receiver);
7400 }
7401 }
7402
7403 pm_compile_call(iseq, node, ret, popped, scope_node, method_id, start);
7404 return;
7405}
7406
7407static inline void
7408pm_compile_call_operator_write_node(rb_iseq_t *iseq, const pm_call_operator_write_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7409{
7410 int flag = 0;
7411
7412 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
7413 flag = VM_CALL_FCALL;
7414 }
7415
7416 PM_COMPILE_NOT_POPPED(node->receiver);
7417
7418 LABEL *safe_label = NULL;
7419 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
7420 safe_label = NEW_LABEL(location->line);
7421 PUSH_INSN(ret, *location, dup);
7422 PUSH_INSNL(ret, *location, branchnil, safe_label);
7423 }
7424
7425 PUSH_INSN(ret, *location, dup);
7426
7427 ID id_read_name = pm_constant_id_lookup(scope_node, node->read_name);
7428 PUSH_SEND_WITH_FLAG(ret, *location, id_read_name, INT2FIX(0), INT2FIX(flag));
7429
7430 PM_COMPILE_NOT_POPPED(node->value);
7431 ID id_operator = pm_constant_id_lookup(scope_node, node->binary_operator);
7432 PUSH_SEND(ret, *location, id_operator, INT2FIX(1));
7433
7434 if (!popped) {
7435 PUSH_INSN(ret, *location, swap);
7436 PUSH_INSN1(ret, *location, topn, INT2FIX(1));
7437 }
7438
7439 ID id_write_name = pm_constant_id_lookup(scope_node, node->write_name);
7440 PUSH_SEND_WITH_FLAG(ret, *location, id_write_name, INT2FIX(1), INT2FIX(flag));
7441
7442 if (safe_label != NULL && popped) PUSH_LABEL(ret, safe_label);
7443 PUSH_INSN(ret, *location, pop);
7444 if (safe_label != NULL && !popped) PUSH_LABEL(ret, safe_label);
7445}
7446
7463static VALUE
7464pm_compile_case_node_dispatch(rb_iseq_t *iseq, VALUE dispatch, const pm_node_t *node, LABEL *label, const pm_scope_node_t *scope_node)
7465{
7466 VALUE key = Qundef;
7467
7468 switch (PM_NODE_TYPE(node)) {
7469 case PM_FLOAT_NODE: {
7470 key = pm_static_literal_value(iseq, node, scope_node);
7471 double intptr;
7472
7473 if (modf(RFLOAT_VALUE(key), &intptr) == 0.0) {
7474 key = (FIXABLE(intptr) ? LONG2FIX((long) intptr) : rb_dbl2big(intptr));
7475 }
7476
7477 break;
7478 }
7479 case PM_FALSE_NODE:
7480 case PM_INTEGER_NODE:
7481 case PM_NIL_NODE:
7482 case PM_SOURCE_FILE_NODE:
7483 case PM_SOURCE_LINE_NODE:
7484 case PM_SYMBOL_NODE:
7485 case PM_TRUE_NODE:
7486 key = pm_static_literal_value(iseq, node, scope_node);
7487 break;
7488 case PM_STRING_NODE: {
7489 const pm_string_node_t *cast = (const pm_string_node_t *) node;
7490 key = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
7491 break;
7492 }
7493 default:
7494 return Qundef;
7495 }
7496
7497 if (NIL_P(rb_hash_lookup(dispatch, key))) {
7498 rb_hash_aset(dispatch, key, ((VALUE) label) | 1);
7499 }
7500
7501 return dispatch;
7502}
7503
7507static inline void
7508pm_compile_case_node(rb_iseq_t *iseq, const pm_case_node_t *cast, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7509{
7510 const pm_parser_t *parser = scope_node->parser;
7511 const pm_node_location_t location = *node_location;
7512 const pm_node_list_t *conditions = &cast->conditions;
7513
7514 // This is the anchor that we will compile the conditions of the various
7515 // `when` nodes into. If a match is found, they will need to jump into
7516 // the body_seq anchor to the correct spot.
7517 DECL_ANCHOR(cond_seq);
7518
7519 // This is the anchor that we will compile the bodies of the various
7520 // `when` nodes into. We'll make sure that the clauses that are compiled
7521 // jump into the correct spots within this anchor.
7522 DECL_ANCHOR(body_seq);
7523
7524 // This is the label where all of the when clauses will jump to if they
7525 // have matched and are done executing their bodies.
7526 LABEL *end_label = NEW_LABEL(location.line);
7527
7528 // If we have a predicate on this case statement, then it's going to
7529 // compare all of the various when clauses to the predicate. If we
7530 // don't, then it's basically an if-elsif-else chain.
7531 if (cast->predicate == NULL) {
7532 // Establish branch coverage for the case node.
7533 VALUE branches = Qfalse;
7534 rb_code_location_t case_location = { 0 };
7535 int branch_id = 0;
7536
7537 if (PM_BRANCH_COVERAGE_P(iseq)) {
7538 case_location = pm_code_location(scope_node, (const pm_node_t *) cast);
7539 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location, "case");
7540 }
7541
7542 // Loop through each clauses in the case node and compile each of
7543 // the conditions within them into cond_seq. If they match, they
7544 // should jump into their respective bodies in body_seq.
7545 for (size_t clause_index = 0; clause_index < conditions->size; clause_index++) {
7546 const pm_when_node_t *clause = (const pm_when_node_t *) conditions->nodes[clause_index];
7547 const pm_node_list_t *conditions = &clause->conditions;
7548
7549 int clause_lineno = pm_node_line_number(parser, (const pm_node_t *) clause);
7550 LABEL *label = NEW_LABEL(clause_lineno);
7551 PUSH_LABEL(body_seq, label);
7552
7553 // Establish branch coverage for the when clause.
7554 if (PM_BRANCH_COVERAGE_P(iseq)) {
7555 rb_code_location_t branch_location = pm_code_location(scope_node, clause->statements != NULL ? ((const pm_node_t *) clause->statements) : ((const pm_node_t *) clause));
7556 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "when", branches);
7557 }
7558
7559 if (clause->statements != NULL) {
7560 pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7561 }
7562 else if (!popped) {
7563 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7564 }
7565
7566 PUSH_INSNL(body_seq, location, jump, end_label);
7567
7568 // Compile each of the conditions for the when clause into the
7569 // cond_seq. Each one should have a unique condition and should
7570 // jump to the subsequent one if it doesn't match.
7571 for (size_t condition_index = 0; condition_index < conditions->size; condition_index++) {
7572 const pm_node_t *condition = conditions->nodes[condition_index];
7573
7574 if (PM_NODE_TYPE_P(condition, PM_SPLAT_NODE)) {
7575 pm_node_location_t cond_location = PM_NODE_START_LOCATION(parser, condition);
7576 PUSH_INSN(cond_seq, cond_location, putnil);
7577 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7578 PUSH_INSN1(cond_seq, cond_location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_WHEN | VM_CHECKMATCH_ARRAY));
7579 PUSH_INSNL(cond_seq, cond_location, branchif, label);
7580 }
7581 else {
7582 LABEL *next_label = NEW_LABEL(pm_node_line_number(parser, condition));
7583 pm_compile_branch_condition(iseq, cond_seq, condition, label, next_label, false, scope_node);
7584 PUSH_LABEL(cond_seq, next_label);
7585 }
7586 }
7587 }
7588
7589 // Establish branch coverage for the else clause (implicit or
7590 // explicit).
7591 if (PM_BRANCH_COVERAGE_P(iseq)) {
7592 rb_code_location_t branch_location;
7593
7594 if (cast->else_clause == NULL) {
7595 branch_location = case_location;
7596 } else if (cast->else_clause->statements == NULL) {
7597 branch_location = pm_code_location(scope_node, (const pm_node_t *) cast->else_clause);
7598 } else {
7599 branch_location = pm_code_location(scope_node, (const pm_node_t *) cast->else_clause->statements);
7600 }
7601
7602 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7603 }
7604
7605 // Compile the else clause if there is one.
7606 if (cast->else_clause != NULL) {
7607 pm_compile_node(iseq, (const pm_node_t *) cast->else_clause, cond_seq, popped, scope_node);
7608 }
7609 else if (!popped) {
7610 PUSH_SYNTHETIC_PUTNIL(cond_seq, iseq);
7611 }
7612
7613 // Finally, jump to the end label if none of the other conditions
7614 // have matched.
7615 PUSH_INSNL(cond_seq, location, jump, end_label);
7616 PUSH_SEQ(ret, cond_seq);
7617 }
7618 else {
7619 // Establish branch coverage for the case node.
7620 VALUE branches = Qfalse;
7621 rb_code_location_t case_location = { 0 };
7622 int branch_id = 0;
7623
7624 if (PM_BRANCH_COVERAGE_P(iseq)) {
7625 case_location = pm_code_location(scope_node, (const pm_node_t *) cast);
7626 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location, "case");
7627 }
7628
7629 // This is the label where everything will fall into if none of the
7630 // conditions matched.
7631 LABEL *else_label = NEW_LABEL(location.line);
7632
7633 // It's possible for us to speed up the case node by using a
7634 // dispatch hash. This is a hash that maps the conditions of the
7635 // various when clauses to the labels of their bodies. If we can
7636 // compile the conditions into a hash key, then we can use a hash
7637 // lookup to jump directly to the correct when clause body.
7638 VALUE dispatch = Qundef;
7639 if (ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction) {
7640 dispatch = rb_hash_new();
7641 RHASH_TBL_RAW(dispatch)->type = &cdhash_type;
7642 }
7643
7644 // We're going to loop through each of the conditions in the case
7645 // node and compile each of their contents into both the cond_seq
7646 // and the body_seq. Each condition will use its own label to jump
7647 // from its conditions into its body.
7648 //
7649 // Note that none of the code in the loop below should be adding
7650 // anything to ret, as we're going to be laying out the entire case
7651 // node instructions later.
7652 for (size_t clause_index = 0; clause_index < conditions->size; clause_index++) {
7653 const pm_when_node_t *clause = (const pm_when_node_t *) conditions->nodes[clause_index];
7654 pm_node_location_t clause_location = PM_NODE_START_LOCATION(parser, (const pm_node_t *) clause);
7655
7656 const pm_node_list_t *conditions = &clause->conditions;
7657 LABEL *label = NEW_LABEL(clause_location.line);
7658
7659 // Compile each of the conditions for the when clause into the
7660 // cond_seq. Each one should have a unique comparison that then
7661 // jumps into the body if it matches.
7662 for (size_t condition_index = 0; condition_index < conditions->size; condition_index++) {
7663 const pm_node_t *condition = conditions->nodes[condition_index];
7664 const pm_node_location_t condition_location = PM_NODE_START_LOCATION(parser, condition);
7665
7666 // If we haven't already abandoned the optimization, then
7667 // we're going to try to compile the condition into the
7668 // dispatch hash.
7669 if (dispatch != Qundef) {
7670 dispatch = pm_compile_case_node_dispatch(iseq, dispatch, condition, label, scope_node);
7671 }
7672
7673 if (PM_NODE_TYPE_P(condition, PM_SPLAT_NODE)) {
7674 PUSH_INSN(cond_seq, condition_location, dup);
7675 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7676 PUSH_INSN1(cond_seq, condition_location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE | VM_CHECKMATCH_ARRAY));
7677 }
7678 else {
7679 if (PM_NODE_TYPE_P(condition, PM_STRING_NODE)) {
7680 const pm_string_node_t *string = (const pm_string_node_t *) condition;
7681 VALUE value = parse_static_literal_string(iseq, scope_node, condition, &string->unescaped);
7682 PUSH_INSN1(cond_seq, condition_location, putobject, value);
7683 }
7684 else {
7685 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7686 }
7687
7688 PUSH_INSN1(cond_seq, condition_location, topn, INT2FIX(1));
7689 PUSH_SEND_WITH_FLAG(cond_seq, condition_location, idEqq, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
7690 }
7691
7692 PUSH_INSNL(cond_seq, condition_location, branchif, label);
7693 }
7694
7695 // Now, add the label to the body and compile the body of the
7696 // when clause. This involves popping the predicate, compiling
7697 // the statements to be executed, and then compiling a jump to
7698 // the end of the case node.
7699 PUSH_LABEL(body_seq, label);
7700 PUSH_INSN(body_seq, clause_location, pop);
7701
7702 // Establish branch coverage for the when clause.
7703 if (PM_BRANCH_COVERAGE_P(iseq)) {
7704 rb_code_location_t branch_location = pm_code_location(scope_node, clause->statements != NULL ? ((const pm_node_t *) clause->statements) : ((const pm_node_t *) clause));
7705 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "when", branches);
7706 }
7707
7708 if (clause->statements != NULL) {
7709 pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7710 }
7711 else if (!popped) {
7712 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7713 }
7714
7715 PUSH_INSNL(body_seq, clause_location, jump, end_label);
7716 }
7717
7718 // Now that we have compiled the conditions and the bodies of the
7719 // various when clauses, we can compile the predicate, lay out the
7720 // conditions, compile the fallback subsequent if there is one, and
7721 // finally put in the bodies of the when clauses.
7722 PM_COMPILE_NOT_POPPED(cast->predicate);
7723
7724 // If we have a dispatch hash, then we'll use it here to create the
7725 // optimization.
7726 if (dispatch != Qundef) {
7727 PUSH_INSN(ret, location, dup);
7728 PUSH_INSN2(ret, location, opt_case_dispatch, dispatch, else_label);
7729 LABEL_REF(else_label);
7730 }
7731
7732 PUSH_SEQ(ret, cond_seq);
7733
7734 // Compile either the explicit else clause or an implicit else
7735 // clause.
7736 PUSH_LABEL(ret, else_label);
7737
7738 if (cast->else_clause != NULL) {
7739 pm_node_location_t else_location = PM_NODE_START_LOCATION(parser, cast->else_clause->statements != NULL ? ((const pm_node_t *) cast->else_clause->statements) : ((const pm_node_t *) cast->else_clause));
7740 PUSH_INSN(ret, else_location, pop);
7741
7742 // Establish branch coverage for the else clause.
7743 if (PM_BRANCH_COVERAGE_P(iseq)) {
7744 rb_code_location_t branch_location = pm_code_location(scope_node, cast->else_clause->statements != NULL ? ((const pm_node_t *) cast->else_clause->statements) : ((const pm_node_t *) cast->else_clause));
7745 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7746 }
7747
7748 PM_COMPILE((const pm_node_t *) cast->else_clause);
7749 PUSH_INSNL(ret, else_location, jump, end_label);
7750 }
7751 else {
7752 PUSH_INSN(ret, location, pop);
7753
7754 // Establish branch coverage for the implicit else clause.
7755 if (PM_BRANCH_COVERAGE_P(iseq)) {
7756 add_trace_branch_coverage(iseq, ret, &case_location, case_location.beg_pos.column, branch_id, "else", branches);
7757 }
7758
7759 if (!popped) PUSH_INSN(ret, location, putnil);
7760 PUSH_INSNL(ret, location, jump, end_label);
7761 }
7762 }
7763
7764 PUSH_SEQ(ret, body_seq);
7765 PUSH_LABEL(ret, end_label);
7766}
7767
7768static inline void
7769pm_compile_case_match_node(rb_iseq_t *iseq, const pm_case_match_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7770{
7771 // This is the anchor that we will compile the bodies of the various
7772 // `in` nodes into. We'll make sure that the patterns that are compiled
7773 // jump into the correct spots within this anchor.
7774 DECL_ANCHOR(body_seq);
7775
7776 // This is the anchor that we will compile the patterns of the various
7777 // `in` nodes into. If a match is found, they will need to jump into the
7778 // body_seq anchor to the correct spot.
7779 DECL_ANCHOR(cond_seq);
7780
7781 // This label is used to indicate the end of the entire node. It is
7782 // jumped to after the entire stack is cleaned up.
7783 LABEL *end_label = NEW_LABEL(location->line);
7784
7785 // This label is used as the fallback for the case match. If no match is
7786 // found, then we jump to this label. This is either an `else` clause or
7787 // an error handler.
7788 LABEL *else_label = NEW_LABEL(location->line);
7789
7790 // We're going to use this to uniquely identify each branch so that we
7791 // can track coverage information.
7792 rb_code_location_t case_location = { 0 };
7793 VALUE branches = Qfalse;
7794 int branch_id = 0;
7795
7796 if (PM_BRANCH_COVERAGE_P(iseq)) {
7797 case_location = pm_code_location(scope_node, (const pm_node_t *) node);
7798 branches = decl_branch_base(iseq, PTR2NUM(node), &case_location, "case");
7799 }
7800
7801 // If there is only one pattern, then the behavior changes a bit. It
7802 // effectively gets treated as a match required node (this is how it is
7803 // represented in the other parser).
7804 bool in_single_pattern = node->else_clause == NULL && node->conditions.size == 1;
7805
7806 // First, we're going to push a bunch of stuff onto the stack that is
7807 // going to serve as our scratch space.
7808 if (in_single_pattern) {
7809 PUSH_INSN(ret, *location, putnil); // key error key
7810 PUSH_INSN(ret, *location, putnil); // key error matchee
7811 PUSH_INSN1(ret, *location, putobject, Qfalse); // key error?
7812 PUSH_INSN(ret, *location, putnil); // error string
7813 }
7814
7815 // Now we're going to compile the value to match against.
7816 PUSH_INSN(ret, *location, putnil); // deconstruct cache
7817 PM_COMPILE_NOT_POPPED(node->predicate);
7818
7819 // Next, we'll loop through every in clause and compile its body into
7820 // the body_seq anchor and its pattern into the cond_seq anchor. We'll
7821 // make sure the pattern knows how to jump correctly into the body if it
7822 // finds a match.
7823 for (size_t index = 0; index < node->conditions.size; index++) {
7824 const pm_node_t *condition = node->conditions.nodes[index];
7825 RUBY_ASSERT(PM_NODE_TYPE_P(condition, PM_IN_NODE));
7826
7827 const pm_in_node_t *in_node = (const pm_in_node_t *) condition;
7828 const pm_node_location_t in_location = PM_NODE_START_LOCATION(scope_node->parser, in_node);
7829 const pm_node_location_t pattern_location = PM_NODE_START_LOCATION(scope_node->parser, in_node->pattern);
7830
7831 if (branch_id) {
7832 PUSH_INSN(body_seq, in_location, putnil);
7833 }
7834
7835 LABEL *body_label = NEW_LABEL(in_location.line);
7836 PUSH_LABEL(body_seq, body_label);
7837 PUSH_INSN1(body_seq, in_location, adjuststack, INT2FIX(in_single_pattern ? 6 : 2));
7838
7839 // Establish branch coverage for the in clause.
7840 if (PM_BRANCH_COVERAGE_P(iseq)) {
7841 rb_code_location_t branch_location = pm_code_location(scope_node, in_node->statements != NULL ? ((const pm_node_t *) in_node->statements) : ((const pm_node_t *) in_node));
7842 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "in", branches);
7843 }
7844
7845 if (in_node->statements != NULL) {
7846 PM_COMPILE_INTO_ANCHOR(body_seq, (const pm_node_t *) in_node->statements);
7847 }
7848 else if (!popped) {
7849 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7850 }
7851
7852 PUSH_INSNL(body_seq, in_location, jump, end_label);
7853 LABEL *next_pattern_label = NEW_LABEL(pattern_location.line);
7854
7855 PUSH_INSN(cond_seq, pattern_location, dup);
7856 pm_compile_pattern(iseq, scope_node, in_node->pattern, cond_seq, body_label, next_pattern_label, in_single_pattern, false, true, 2);
7857 PUSH_LABEL(cond_seq, next_pattern_label);
7858 LABEL_UNREMOVABLE(next_pattern_label);
7859 }
7860
7861 if (node->else_clause != NULL) {
7862 // If we have an `else` clause, then this becomes our fallback (and
7863 // there is no need to compile in code to potentially raise an
7864 // error).
7865 const pm_else_node_t *else_node = node->else_clause;
7866
7867 PUSH_LABEL(cond_seq, else_label);
7868 PUSH_INSN(cond_seq, *location, pop);
7869 PUSH_INSN(cond_seq, *location, pop);
7870
7871 // Establish branch coverage for the else clause.
7872 if (PM_BRANCH_COVERAGE_P(iseq)) {
7873 rb_code_location_t branch_location = pm_code_location(scope_node, else_node->statements != NULL ? ((const pm_node_t *) else_node->statements) : ((const pm_node_t *) else_node));
7874 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7875 }
7876
7877 PM_COMPILE_INTO_ANCHOR(cond_seq, (const pm_node_t *) else_node);
7878 PUSH_INSNL(cond_seq, *location, jump, end_label);
7879 PUSH_INSN(cond_seq, *location, putnil);
7880 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7881 }
7882 else {
7883 // Otherwise, if we do not have an `else` clause, we will compile in
7884 // the code to handle raising an appropriate error.
7885 PUSH_LABEL(cond_seq, else_label);
7886
7887 // Establish branch coverage for the implicit else clause.
7888 add_trace_branch_coverage(iseq, cond_seq, &case_location, case_location.beg_pos.column, branch_id, "else", branches);
7889
7890 if (in_single_pattern) {
7891 pm_compile_pattern_error_handler(iseq, scope_node, (const pm_node_t *) node, cond_seq, end_label, popped);
7892 }
7893 else {
7894 PUSH_INSN1(cond_seq, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7895 PUSH_INSN1(cond_seq, *location, putobject, rb_eNoMatchingPatternError);
7896 PUSH_INSN1(cond_seq, *location, topn, INT2FIX(2));
7897 PUSH_SEND(cond_seq, *location, id_core_raise, INT2FIX(2));
7898
7899 PUSH_INSN1(cond_seq, *location, adjuststack, INT2FIX(3));
7900 if (!popped) PUSH_INSN(cond_seq, *location, putnil);
7901 PUSH_INSNL(cond_seq, *location, jump, end_label);
7902 PUSH_INSN1(cond_seq, *location, dupn, INT2FIX(1));
7903 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7904 }
7905 }
7906
7907 // At the end of all of this compilation, we will add the code for the
7908 // conditions first, then the various bodies, then mark the end of the
7909 // entire sequence with the end label.
7910 PUSH_SEQ(ret, cond_seq);
7911 PUSH_SEQ(ret, body_seq);
7912 PUSH_LABEL(ret, end_label);
7913}
7914
7915static inline void
7916pm_compile_forwarding_super_node(rb_iseq_t *iseq, const pm_forwarding_super_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
7917{
7918 const rb_iseq_t *block = NULL;
7919 const rb_iseq_t *previous_block = NULL;
7920 LABEL *retry_label = NULL;
7921 LABEL *retry_end_l = NULL;
7922
7923 if (node->block != NULL) {
7924 previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
7925 ISEQ_COMPILE_DATA(iseq)->current_block = NULL;
7926
7927 retry_label = NEW_LABEL(location->line);
7928 retry_end_l = NEW_LABEL(location->line);
7929
7930 PUSH_LABEL(ret, retry_label);
7931 }
7932 else {
7933 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
7934 }
7935
7936 PUSH_INSN(ret, *location, putself);
7937 int flag = VM_CALL_ZSUPER | VM_CALL_SUPER | VM_CALL_FCALL;
7938
7939 if (node->block != NULL) {
7940 pm_scope_node_t next_scope_node;
7941 pm_scope_node_init((const pm_node_t *) node->block, &next_scope_node, scope_node);
7942
7943 ISEQ_COMPILE_DATA(iseq)->current_block = block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->line);
7944 pm_scope_node_destroy(&next_scope_node);
7945 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) block);
7946 }
7947
7948 DECL_ANCHOR(args);
7949
7950 struct rb_iseq_constant_body *const body = ISEQ_BODY(iseq);
7951 const rb_iseq_t *local_iseq = body->local_iseq;
7952 const struct rb_iseq_constant_body *const local_body = ISEQ_BODY(local_iseq);
7953
7954 int argc = 0;
7955 int depth = get_lvar_level(iseq);
7956
7957 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
7958 flag |= VM_CALL_FORWARDING;
7959 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
7960 PUSH_GETLOCAL(ret, *location, mult_local.index, mult_local.level);
7961
7962 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, 0, flag, NULL, block != NULL);
7963 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, block);
7964
7965 if (popped) PUSH_INSN(ret, *location, pop);
7966 if (node->block) {
7967 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
7968 }
7969 return;
7970 }
7971
7972 if (local_body->param.flags.has_lead) {
7973 /* required arguments */
7974 for (int i = 0; i < local_body->param.lead_num; i++) {
7975 int idx = local_body->local_table_size - i;
7976 PUSH_GETLOCAL(args, *location, idx, depth);
7977 }
7978 argc += local_body->param.lead_num;
7979 }
7980
7981 if (local_body->param.flags.has_opt) {
7982 /* optional arguments */
7983 for (int j = 0; j < local_body->param.opt_num; j++) {
7984 int idx = local_body->local_table_size - (argc + j);
7985 PUSH_GETLOCAL(args, *location, idx, depth);
7986 }
7987 argc += local_body->param.opt_num;
7988 }
7989
7990 if (local_body->param.flags.has_rest) {
7991 /* rest argument */
7992 int idx = local_body->local_table_size - local_body->param.rest_start;
7993 PUSH_GETLOCAL(args, *location, idx, depth);
7994 PUSH_INSN1(args, *location, splatarray, Qfalse);
7995
7996 argc = local_body->param.rest_start + 1;
7997 flag |= VM_CALL_ARGS_SPLAT;
7998 }
7999
8000 if (local_body->param.flags.has_post) {
8001 /* post arguments */
8002 int post_len = local_body->param.post_num;
8003 int post_start = local_body->param.post_start;
8004
8005 int j = 0;
8006 for (; j < post_len; j++) {
8007 int idx = local_body->local_table_size - (post_start + j);
8008 PUSH_GETLOCAL(args, *location, idx, depth);
8009 }
8010
8011 if (local_body->param.flags.has_rest) {
8012 // argc remains unchanged from rest branch
8013 PUSH_INSN1(args, *location, newarray, INT2FIX(j));
8014 PUSH_INSN(args, *location, concatarray);
8015 }
8016 else {
8017 argc = post_len + post_start;
8018 }
8019 }
8020
8021 const struct rb_iseq_param_keyword *const local_keyword = local_body->param.keyword;
8022 if (local_body->param.flags.has_kw) {
8023 int local_size = local_body->local_table_size;
8024 argc++;
8025
8026 PUSH_INSN1(args, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
8027
8028 if (local_body->param.flags.has_kwrest) {
8029 int idx = local_body->local_table_size - local_keyword->rest_start;
8030 PUSH_GETLOCAL(args, *location, idx, depth);
8031 RUBY_ASSERT(local_keyword->num > 0);
8032 PUSH_SEND(args, *location, rb_intern("dup"), INT2FIX(0));
8033 }
8034 else {
8035 PUSH_INSN1(args, *location, newhash, INT2FIX(0));
8036 }
8037 int i = 0;
8038 for (; i < local_keyword->num; ++i) {
8039 ID id = local_keyword->table[i];
8040 int idx = local_size - get_local_var_idx(local_iseq, id);
8041
8042 {
8043 VALUE operand = ID2SYM(id);
8044 PUSH_INSN1(args, *location, putobject, operand);
8045 }
8046
8047 PUSH_GETLOCAL(args, *location, idx, depth);
8048 }
8049
8050 PUSH_SEND(args, *location, id_core_hash_merge_ptr, INT2FIX(i * 2 + 1));
8051 flag |= VM_CALL_KW_SPLAT| VM_CALL_KW_SPLAT_MUT;
8052 }
8053 else if (local_body->param.flags.has_kwrest) {
8054 int idx = local_body->local_table_size - local_keyword->rest_start;
8055 PUSH_GETLOCAL(args, *location, idx, depth);
8056 argc++;
8057 flag |= VM_CALL_KW_SPLAT;
8058 }
8059
8060 PUSH_SEQ(ret, args);
8061
8062 {
8063 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flag, NULL, block != NULL);
8064 PUSH_INSN2(ret, *location, invokesuper, callinfo, block);
8065 }
8066
8067 if (node->block != NULL) {
8068 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8069 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, block, retry_end_l);
8070 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8071 }
8072
8073 if (popped) PUSH_INSN(ret, *location, pop);
8074}
8075
8076static inline void
8077pm_compile_match_required_node(rb_iseq_t *iseq, const pm_match_required_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8078{
8079 LABEL *matched_label = NEW_LABEL(location->line);
8080 LABEL *unmatched_label = NEW_LABEL(location->line);
8081 LABEL *done_label = NEW_LABEL(location->line);
8082
8083 // First, we're going to push a bunch of stuff onto the stack that is
8084 // going to serve as our scratch space.
8085 PUSH_INSN(ret, *location, putnil); // key error key
8086 PUSH_INSN(ret, *location, putnil); // key error matchee
8087 PUSH_INSN1(ret, *location, putobject, Qfalse); // key error?
8088 PUSH_INSN(ret, *location, putnil); // error string
8089 PUSH_INSN(ret, *location, putnil); // deconstruct cache
8090
8091 // Next we're going to compile the value expression such that it's on
8092 // the stack.
8093 PM_COMPILE_NOT_POPPED(node->value);
8094
8095 // Here we'll dup it so that it can be used for comparison, but also be
8096 // used for error handling.
8097 PUSH_INSN(ret, *location, dup);
8098
8099 // Next we'll compile the pattern. We indicate to the pm_compile_pattern
8100 // function that this is the only pattern that will be matched against
8101 // through the in_single_pattern parameter. We also indicate that the
8102 // value to compare against is 2 slots from the top of the stack (the
8103 // base_index parameter).
8104 pm_compile_pattern(iseq, scope_node, node->pattern, ret, matched_label, unmatched_label, true, false, true, 2);
8105
8106 // If the pattern did not match the value, then we're going to compile
8107 // in our error handler code. This will determine which error to raise
8108 // and raise it.
8109 PUSH_LABEL(ret, unmatched_label);
8110 pm_compile_pattern_error_handler(iseq, scope_node, (const pm_node_t *) node, ret, done_label, popped);
8111
8112 // If the pattern did match, we'll clean up the values we've pushed onto
8113 // the stack and then push nil onto the stack if it's not popped.
8114 PUSH_LABEL(ret, matched_label);
8115 PUSH_INSN1(ret, *location, adjuststack, INT2FIX(6));
8116 if (!popped) PUSH_INSN(ret, *location, putnil);
8117 PUSH_INSNL(ret, *location, jump, done_label);
8118
8119 PUSH_LABEL(ret, done_label);
8120}
8121
8122static inline void
8123pm_compile_match_write_node(rb_iseq_t *iseq, const pm_match_write_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8124{
8125 LABEL *fail_label = NEW_LABEL(location->line);
8126 LABEL *end_label = NEW_LABEL(location->line);
8127
8128 // First, we'll compile the call so that all of its instructions are
8129 // present. Then we'll compile all of the local variable targets.
8130 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->call);
8131
8132 // Now, check if the match was successful. If it was, then we'll
8133 // continue on and assign local variables. Otherwise we'll skip over the
8134 // assignment code.
8135 {
8136 VALUE operand = rb_id2sym(idBACKREF);
8137 PUSH_INSN1(ret, *location, getglobal, operand);
8138 }
8139
8140 PUSH_INSN(ret, *location, dup);
8141 PUSH_INSNL(ret, *location, branchunless, fail_label);
8142
8143 // If there's only a single local variable target, we can skip some of
8144 // the bookkeeping, so we'll put a special branch here.
8145 size_t targets_count = node->targets.size;
8146
8147 if (targets_count == 1) {
8148 const pm_node_t *target = node->targets.nodes[0];
8149 RUBY_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_TARGET_NODE));
8150
8151 const pm_local_variable_target_node_t *local_target = (const pm_local_variable_target_node_t *) target;
8152 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->name, local_target->depth);
8153
8154 {
8155 VALUE operand = rb_id2sym(pm_constant_id_lookup(scope_node, local_target->name));
8156 PUSH_INSN1(ret, *location, putobject, operand);
8157 }
8158
8159 PUSH_SEND(ret, *location, idAREF, INT2FIX(1));
8160 PUSH_LABEL(ret, fail_label);
8161 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8162 if (popped) PUSH_INSN(ret, *location, pop);
8163 return;
8164 }
8165
8166 DECL_ANCHOR(fail_anchor);
8167
8168 // Otherwise there is more than one local variable target, so we'll need
8169 // to do some bookkeeping.
8170 for (size_t targets_index = 0; targets_index < targets_count; targets_index++) {
8171 const pm_node_t *target = node->targets.nodes[targets_index];
8172 RUBY_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_TARGET_NODE));
8173
8174 const pm_local_variable_target_node_t *local_target = (const pm_local_variable_target_node_t *) target;
8175 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->name, local_target->depth);
8176
8177 if (((size_t) targets_index) < (targets_count - 1)) {
8178 PUSH_INSN(ret, *location, dup);
8179 }
8180
8181 {
8182 VALUE operand = rb_id2sym(pm_constant_id_lookup(scope_node, local_target->name));
8183 PUSH_INSN1(ret, *location, putobject, operand);
8184 }
8185
8186 PUSH_SEND(ret, *location, idAREF, INT2FIX(1));
8187 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8188
8189 PUSH_INSN(fail_anchor, *location, putnil);
8190 PUSH_SETLOCAL(fail_anchor, *location, index.index, index.level);
8191 }
8192
8193 // Since we matched successfully, now we'll jump to the end.
8194 PUSH_INSNL(ret, *location, jump, end_label);
8195
8196 // In the case that the match failed, we'll loop through each local
8197 // variable target and set all of them to `nil`.
8198 PUSH_LABEL(ret, fail_label);
8199 PUSH_INSN(ret, *location, pop);
8200 PUSH_SEQ(ret, fail_anchor);
8201
8202 // Finally, we can push the end label for either case.
8203 PUSH_LABEL(ret, end_label);
8204 if (popped) PUSH_INSN(ret, *location, pop);
8205}
8206
8207static inline void
8208pm_compile_next_node(rb_iseq_t *iseq, const pm_next_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8209{
8210 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
8211 LABEL *splabel = NEW_LABEL(0);
8212 PUSH_LABEL(ret, splabel);
8213
8214 if (node->arguments) {
8215 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8216 }
8217 else {
8218 PUSH_INSN(ret, *location, putnil);
8219 }
8220 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8221
8222 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8223 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8224
8225 PUSH_ADJUST_RESTORE(ret, splabel);
8226 if (!popped) PUSH_INSN(ret, *location, putnil);
8227 }
8228 else if (ISEQ_COMPILE_DATA(iseq)->end_label && can_add_ensure_iseq(iseq)) {
8229 LABEL *splabel = NEW_LABEL(0);
8230
8231 PUSH_LABEL(ret, splabel);
8232 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8233
8234 if (node->arguments != NULL) {
8235 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8236 }
8237 else {
8238 PUSH_INSN(ret, *location, putnil);
8239 }
8240
8241 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8242 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
8243 PUSH_ADJUST_RESTORE(ret, splabel);
8244 splabel->unremovable = FALSE;
8245
8246 if (!popped) PUSH_INSN(ret, *location, putnil);
8247 }
8248 else {
8249 const rb_iseq_t *ip = iseq;
8250 unsigned long throw_flag = 0;
8251
8252 while (ip) {
8253 if (!ISEQ_COMPILE_DATA(ip)) {
8254 ip = 0;
8255 break;
8256 }
8257
8258 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
8259 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8260 /* while loop */
8261 break;
8262 }
8263 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
8264 break;
8265 }
8266 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
8267 COMPILE_ERROR(iseq, location->line, "Invalid next");
8268 return;
8269 }
8270
8271 ip = ISEQ_BODY(ip)->parent_iseq;
8272 }
8273
8274 if (ip != 0) {
8275 if (node->arguments) {
8276 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8277 }
8278 else {
8279 PUSH_INSN(ret, *location, putnil);
8280 }
8281
8282 PUSH_INSN1(ret, *location, throw, INT2FIX(throw_flag | TAG_NEXT));
8283 if (popped) PUSH_INSN(ret, *location, pop);
8284 }
8285 else {
8286 COMPILE_ERROR(iseq, location->line, "Invalid next");
8287 }
8288 }
8289}
8290
8291static inline void
8292pm_compile_redo_node(rb_iseq_t *iseq, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8293{
8294 if (ISEQ_COMPILE_DATA(iseq)->redo_label && can_add_ensure_iseq(iseq)) {
8295 LABEL *splabel = NEW_LABEL(0);
8296
8297 PUSH_LABEL(ret, splabel);
8298 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8299 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8300
8301 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->redo_label);
8302 PUSH_ADJUST_RESTORE(ret, splabel);
8303 if (!popped) PUSH_INSN(ret, *location, putnil);
8304 }
8305 else if (ISEQ_BODY(iseq)->type != ISEQ_TYPE_EVAL && ISEQ_COMPILE_DATA(iseq)->start_label && can_add_ensure_iseq(iseq)) {
8306 LABEL *splabel = NEW_LABEL(0);
8307
8308 PUSH_LABEL(ret, splabel);
8309 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8310 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8311
8312 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8313 PUSH_ADJUST_RESTORE(ret, splabel);
8314 if (!popped) PUSH_INSN(ret, *location, putnil);
8315 }
8316 else {
8317 const rb_iseq_t *ip = iseq;
8318
8319 while (ip) {
8320 if (!ISEQ_COMPILE_DATA(ip)) {
8321 ip = 0;
8322 break;
8323 }
8324
8325 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8326 break;
8327 }
8328 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
8329 break;
8330 }
8331 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
8332 COMPILE_ERROR(iseq, location->line, "Invalid redo");
8333 return;
8334 }
8335
8336 ip = ISEQ_BODY(ip)->parent_iseq;
8337 }
8338
8339 if (ip != 0) {
8340 PUSH_INSN(ret, *location, putnil);
8341 PUSH_INSN1(ret, *location, throw, INT2FIX(VM_THROW_NO_ESCAPE_FLAG | TAG_REDO));
8342 if (popped) PUSH_INSN(ret, *location, pop);
8343 }
8344 else {
8345 COMPILE_ERROR(iseq, location->line, "Invalid redo");
8346 }
8347 }
8348}
8349
8350static inline void
8351pm_compile_rescue_node(rb_iseq_t *iseq, const pm_rescue_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8352{
8353 iseq_set_exception_local_table(iseq);
8354
8355 // First, establish the labels that we need to be able to jump to within
8356 // this compilation block.
8357 LABEL *exception_match_label = NEW_LABEL(location->line);
8358 LABEL *rescue_end_label = NEW_LABEL(location->line);
8359
8360 // Next, compile each of the exceptions that we're going to be
8361 // handling. For each one, we'll add instructions to check if the
8362 // exception matches the raised one, and if it does then jump to the
8363 // exception_match_label label. Otherwise it will fall through to the
8364 // subsequent check. If there are no exceptions, we'll only check
8365 // StandardError.
8366 const pm_node_list_t *exceptions = &node->exceptions;
8367
8368 if (exceptions->size > 0) {
8369 for (size_t index = 0; index < exceptions->size; index++) {
8370 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8371 PM_COMPILE(exceptions->nodes[index]);
8372 int checkmatch_flags = VM_CHECKMATCH_TYPE_RESCUE;
8373 if (PM_NODE_TYPE_P(exceptions->nodes[index], PM_SPLAT_NODE)) {
8374 checkmatch_flags |= VM_CHECKMATCH_ARRAY;
8375 }
8376 PUSH_INSN1(ret, *location, checkmatch, INT2FIX(checkmatch_flags));
8377 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8378 }
8379 }
8380 else {
8381 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8382 PUSH_INSN1(ret, *location, putobject, rb_eStandardError);
8383 PUSH_INSN1(ret, *location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
8384 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8385 }
8386
8387 // If none of the exceptions that we are matching against matched, then
8388 // we'll jump straight to the rescue_end_label label.
8389 PUSH_INSNL(ret, *location, jump, rescue_end_label);
8390
8391 // Here we have the exception_match_label, which is where the
8392 // control-flow goes in the case that one of the exceptions matched.
8393 // Here we will compile the instructions to handle the exception.
8394 PUSH_LABEL(ret, exception_match_label);
8395 PUSH_TRACE(ret, RUBY_EVENT_RESCUE);
8396
8397 // If we have a reference to the exception, then we'll compile the write
8398 // into the instruction sequence. This can look quite different
8399 // depending on the kind of write being performed.
8400 if (node->reference) {
8401 DECL_ANCHOR(writes);
8402 DECL_ANCHOR(cleanup);
8403
8404 pm_compile_target_node(iseq, node->reference, ret, writes, cleanup, scope_node, NULL);
8405 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8406
8407 PUSH_SEQ(ret, writes);
8408 PUSH_SEQ(ret, cleanup);
8409 }
8410
8411 // If we have statements to execute, we'll compile them here. Otherwise
8412 // we'll push nil onto the stack.
8413 if (node->statements != NULL) {
8414 // We'll temporarily remove the end_label location from the iseq
8415 // when compiling the statements so that next/redo statements
8416 // inside the body will throw to the correct place instead of
8417 // jumping straight to the end of this iseq
8418 LABEL *prev_end = ISEQ_COMPILE_DATA(iseq)->end_label;
8419 ISEQ_COMPILE_DATA(iseq)->end_label = NULL;
8420
8421 PM_COMPILE((const pm_node_t *) node->statements);
8422
8423 // Now restore the end_label
8424 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end;
8425 }
8426 else {
8427 PUSH_INSN(ret, *location, putnil);
8428 }
8429
8430 PUSH_INSN(ret, *location, leave);
8431
8432 // Here we'll insert the rescue_end_label label, which is jumped to if
8433 // none of the exceptions matched. It will cause the control-flow to
8434 // either jump to the next rescue clause or it will fall through to the
8435 // subsequent instruction returning the raised error.
8436 PUSH_LABEL(ret, rescue_end_label);
8437 if (node->subsequent != NULL) {
8438 PM_COMPILE((const pm_node_t *) node->subsequent);
8439 }
8440 else {
8441 PUSH_GETLOCAL(ret, *location, 1, 0);
8442 }
8443}
8444
8445static inline void
8446pm_compile_return_node(rb_iseq_t *iseq, const pm_return_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8447{
8448 const pm_arguments_node_t *arguments = node->arguments;
8449 enum rb_iseq_type type = ISEQ_BODY(iseq)->type;
8450 LABEL *splabel = 0;
8451
8452 const rb_iseq_t *parent_iseq = iseq;
8453 enum rb_iseq_type parent_type = ISEQ_BODY(parent_iseq)->type;
8454 while (parent_type == ISEQ_TYPE_RESCUE || parent_type == ISEQ_TYPE_ENSURE) {
8455 if (!(parent_iseq = ISEQ_BODY(parent_iseq)->parent_iseq)) break;
8456 parent_type = ISEQ_BODY(parent_iseq)->type;
8457 }
8458
8459 switch (parent_type) {
8460 case ISEQ_TYPE_TOP:
8461 case ISEQ_TYPE_MAIN:
8462 if (arguments) {
8463 rb_warn("argument of top-level return is ignored");
8464 }
8465 if (parent_iseq == iseq) {
8466 type = ISEQ_TYPE_METHOD;
8467 }
8468 break;
8469 default:
8470 break;
8471 }
8472
8473 if (type == ISEQ_TYPE_METHOD) {
8474 splabel = NEW_LABEL(0);
8475 PUSH_LABEL(ret, splabel);
8476 PUSH_ADJUST(ret, *location, 0);
8477 }
8478
8479 if (arguments != NULL) {
8480 PM_COMPILE_NOT_POPPED((const pm_node_t *) arguments);
8481 }
8482 else {
8483 PUSH_INSN(ret, *location, putnil);
8484 }
8485
8486 if (type == ISEQ_TYPE_METHOD && can_add_ensure_iseq(iseq)) {
8487 pm_add_ensure_iseq(ret, iseq, 1, scope_node);
8488 PUSH_TRACE(ret, RUBY_EVENT_RETURN);
8489 PUSH_INSN(ret, *location, leave);
8490 PUSH_ADJUST_RESTORE(ret, splabel);
8491 if (!popped) PUSH_INSN(ret, *location, putnil);
8492 }
8493 else {
8494 PUSH_INSN1(ret, *location, throw, INT2FIX(TAG_RETURN));
8495 if (popped) PUSH_INSN(ret, *location, pop);
8496 }
8497}
8498
8499static inline void
8500pm_compile_super_node(rb_iseq_t *iseq, const pm_super_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8501{
8502 DECL_ANCHOR(args);
8503
8504 LABEL *retry_label = NEW_LABEL(location->line);
8505 LABEL *retry_end_l = NEW_LABEL(location->line);
8506
8507 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
8508 const rb_iseq_t *current_block;
8509 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NULL;
8510
8511 PUSH_LABEL(ret, retry_label);
8512 PUSH_INSN(ret, *location, putself);
8513
8514 int flags = 0;
8515 struct rb_callinfo_kwarg *keywords = NULL;
8516 int argc = pm_setup_args(node->arguments, node->block, &flags, &keywords, iseq, ret, scope_node, location);
8517 bool is_forwardable = (node->arguments != NULL) && PM_NODE_FLAG_P(node->arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING);
8518 flags |= VM_CALL_SUPER | VM_CALL_FCALL;
8519
8520 if (node->block && PM_NODE_TYPE_P(node->block, PM_BLOCK_NODE)) {
8521 pm_scope_node_t next_scope_node;
8522 pm_scope_node_init(node->block, &next_scope_node, scope_node);
8523
8524 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->line);
8525 pm_scope_node_destroy(&next_scope_node);
8526 }
8527
8528 if (!node->block) {
8529 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8530 }
8531
8532 if ((flags & VM_CALL_ARGS_BLOCKARG) && (flags & VM_CALL_KW_SPLAT) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
8533 PUSH_INSN(args, *location, splatkw);
8534 }
8535
8536 PUSH_SEQ(ret, args);
8537 if (is_forwardable && ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
8538 flags |= VM_CALL_FORWARDING;
8539
8540 {
8541 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8542 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, current_block);
8543 }
8544 }
8545 else {
8546 {
8547 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8548 PUSH_INSN2(ret, *location, invokesuper, callinfo, current_block);
8549 }
8550
8551 }
8552
8553 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8554
8555 if (popped) PUSH_INSN(ret, *location, pop);
8556 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8557 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, current_block, retry_end_l);
8558}
8559
8560static inline void
8561pm_compile_yield_node(rb_iseq_t *iseq, const pm_yield_node_t *node, const pm_node_location_t *location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8562{
8563 switch (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->type) {
8564 case ISEQ_TYPE_TOP:
8565 case ISEQ_TYPE_MAIN:
8566 case ISEQ_TYPE_CLASS:
8567 COMPILE_ERROR(iseq, location->line, "Invalid yield");
8568 return;
8569 default: /* valid */;
8570 }
8571
8572 int argc = 0;
8573 int flags = 0;
8574 struct rb_callinfo_kwarg *keywords = NULL;
8575
8576 if (node->arguments) {
8577 argc = pm_setup_args(node->arguments, NULL, &flags, &keywords, iseq, ret, scope_node, location);
8578 }
8579
8580 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, FALSE);
8581 PUSH_INSN1(ret, *location, invokeblock, callinfo);
8582
8583 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8584 if (popped) PUSH_INSN(ret, *location, pop);
8585
8586 int level = 0;
8587 for (const rb_iseq_t *tmp_iseq = iseq; tmp_iseq != ISEQ_BODY(iseq)->local_iseq; level++) {
8588 tmp_iseq = ISEQ_BODY(tmp_iseq)->parent_iseq;
8589 }
8590
8591 if (level > 0) access_outer_variables(iseq, level, rb_intern("yield"), true);
8592}
8593
8604static void
8605pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8606{
8607 const pm_parser_t *parser = scope_node->parser;
8608 const pm_node_location_t location = PM_NODE_START_LOCATION(parser, node);
8609 int lineno = (int) location.line;
8610
8611 if (PM_NODE_TYPE_P(node, PM_BEGIN_NODE) && (((const pm_begin_node_t *) node)->statements == NULL) && (((const pm_begin_node_t *) node)->rescue_clause != NULL)) {
8612 // If this node is a begin node and it has empty statements and also
8613 // has a rescue clause, then the other parser considers it as
8614 // starting on the same line as the rescue, as opposed to the
8615 // location of the begin keyword. We replicate that behavior here.
8616 lineno = (int) PM_NODE_START_LINE_COLUMN(parser, ((const pm_begin_node_t *) node)->rescue_clause).line;
8617 }
8618
8619 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_NEWLINE) && ISEQ_COMPILE_DATA(iseq)->last_line != lineno) {
8620 // If this node has the newline flag set and it is on a new line
8621 // from the previous nodes that have been compiled for this ISEQ,
8622 // then we need to emit a newline event.
8623 int event = RUBY_EVENT_LINE;
8624
8625 ISEQ_COMPILE_DATA(iseq)->last_line = lineno;
8626 if (lineno > 0 && ISEQ_COVERAGE(iseq) && ISEQ_LINE_COVERAGE(iseq)) {
8627 event |= RUBY_EVENT_COVERAGE_LINE;
8628 }
8629 PUSH_TRACE(ret, event);
8630 }
8631
8632 switch (PM_NODE_TYPE(node)) {
8633 case PM_ALIAS_GLOBAL_VARIABLE_NODE:
8634 // alias $foo $bar
8635 // ^^^^^^^^^^^^^^^
8636 pm_compile_alias_global_variable_node(iseq, (const pm_alias_global_variable_node_t *) node, &location, ret, popped, scope_node);
8637 return;
8638 case PM_ALIAS_METHOD_NODE:
8639 // alias foo bar
8640 // ^^^^^^^^^^^^^
8641 pm_compile_alias_method_node(iseq, (const pm_alias_method_node_t *) node, &location, ret, popped, scope_node);
8642 return;
8643 case PM_AND_NODE:
8644 // a and b
8645 // ^^^^^^^
8646 pm_compile_and_node(iseq, (const pm_and_node_t *) node, &location, ret, popped, scope_node);
8647 return;
8648 case PM_ARGUMENTS_NODE: {
8649 // break foo
8650 // ^^^
8651 //
8652 // These are ArgumentsNodes that are not compiled directly by their
8653 // parent call nodes, used in the cases of NextNodes, ReturnNodes, and
8654 // BreakNodes. They can create an array like ArrayNode.
8655 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
8656 const pm_node_list_t *elements = &cast->arguments;
8657
8658 if (elements->size == 1) {
8659 // If we are only returning a single element through one of the jump
8660 // nodes, then we will only compile that node directly.
8661 PM_COMPILE(elements->nodes[0]);
8662 }
8663 else {
8664 pm_compile_array_node(iseq, (const pm_node_t *) cast, elements, &location, ret, popped, scope_node);
8665 }
8666 return;
8667 }
8668 case PM_ARRAY_NODE: {
8669 // [foo, bar, baz]
8670 // ^^^^^^^^^^^^^^^
8671 const pm_array_node_t *cast = (const pm_array_node_t *) node;
8672 pm_compile_array_node(iseq, (const pm_node_t *) cast, &cast->elements, &location, ret, popped, scope_node);
8673 return;
8674 }
8675 case PM_ASSOC_NODE: {
8676 // { foo: 1 }
8677 // ^^^^^^
8678 //
8679 // foo(bar: 1)
8680 // ^^^^^^
8681 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
8682
8683 PM_COMPILE(cast->key);
8684 PM_COMPILE(cast->value);
8685
8686 return;
8687 }
8688 case PM_ASSOC_SPLAT_NODE: {
8689 // { **foo }
8690 // ^^^^^
8691 //
8692 // def foo(**); bar(**); end
8693 // ^^
8694 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
8695
8696 if (cast->value != NULL) {
8697 PM_COMPILE(cast->value);
8698 }
8699 else if (!popped) {
8700 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
8701 PUSH_GETLOCAL(ret, location, index.index, index.level);
8702 }
8703
8704 return;
8705 }
8706 case PM_BACK_REFERENCE_READ_NODE: {
8707 // $+
8708 // ^^
8709 if (!popped) {
8710 const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
8711 VALUE backref = pm_compile_back_reference_ref(cast);
8712
8713 PUSH_INSN2(ret, location, getspecial, INT2FIX(1), backref);
8714 }
8715 return;
8716 }
8717 case PM_BEGIN_NODE: {
8718 // begin end
8719 // ^^^^^^^^^
8720 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
8721
8722 if (cast->ensure_clause) {
8723 // Compiling the ensure clause will compile the rescue clause (if
8724 // there is one), which will compile the begin statements.
8725 pm_compile_ensure(iseq, cast, &location, ret, popped, scope_node);
8726 }
8727 else if (cast->rescue_clause) {
8728 // Compiling rescue will compile begin statements (if applicable).
8729 pm_compile_rescue(iseq, cast, &location, ret, popped, scope_node);
8730 }
8731 else {
8732 // If there is neither ensure or rescue, the just compile the
8733 // statements.
8734 if (cast->statements != NULL) {
8735 PM_COMPILE((const pm_node_t *) cast->statements);
8736 }
8737 else if (!popped) {
8738 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
8739 }
8740 }
8741 return;
8742 }
8743 case PM_BLOCK_ARGUMENT_NODE: {
8744 // foo(&bar)
8745 // ^^^^
8746 const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
8747
8748 if (cast->expression != NULL) {
8749 PM_COMPILE(cast->expression);
8750 }
8751 else {
8752 // If there's no expression, this must be block forwarding.
8753 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
8754 PUSH_INSN2(ret, location, getblockparamproxy, INT2FIX(local_index.index + VM_ENV_DATA_SIZE - 1), INT2FIX(local_index.level));
8755 }
8756 return;
8757 }
8758 case PM_BREAK_NODE:
8759 // break
8760 // ^^^^^
8761 //
8762 // break foo
8763 // ^^^^^^^^^
8764 pm_compile_break_node(iseq, (const pm_break_node_t *) node, &location, ret, popped, scope_node);
8765 return;
8766 case PM_CALL_NODE:
8767 // foo
8768 // ^^^
8769 //
8770 // foo.bar
8771 // ^^^^^^^
8772 //
8773 // foo.bar() {}
8774 // ^^^^^^^^^^^^
8775 pm_compile_call_node(iseq, (const pm_call_node_t *) node, ret, popped, scope_node);
8776 return;
8777 case PM_CALL_AND_WRITE_NODE: {
8778 // foo.bar &&= baz
8779 // ^^^^^^^^^^^^^^^
8780 const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
8781 pm_compile_call_and_or_write_node(iseq, true, cast->receiver, cast->value, cast->write_name, cast->read_name, PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION), &location, ret, popped, scope_node);
8782 return;
8783 }
8784 case PM_CALL_OR_WRITE_NODE: {
8785 // foo.bar ||= baz
8786 // ^^^^^^^^^^^^^^^
8787 const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
8788 pm_compile_call_and_or_write_node(iseq, false, cast->receiver, cast->value, cast->write_name, cast->read_name, PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION), &location, ret, popped, scope_node);
8789 return;
8790 }
8791 case PM_CALL_OPERATOR_WRITE_NODE:
8792 // foo.bar += baz
8793 // ^^^^^^^^^^^^^^^
8794 //
8795 // Call operator writes occur when you have a call node on the left-hand
8796 // side of a write operator that is not `=`. As an example,
8797 // `foo.bar *= 1`. This breaks down to caching the receiver on the
8798 // stack and then performing three method calls, one to read the value,
8799 // one to compute the result, and one to write the result back to the
8800 // receiver.
8801 pm_compile_call_operator_write_node(iseq, (const pm_call_operator_write_node_t *) node, &location, ret, popped, scope_node);
8802 return;
8803 case PM_CASE_NODE:
8804 // case foo; when bar; end
8805 // ^^^^^^^^^^^^^^^^^^^^^^^
8806 pm_compile_case_node(iseq, (const pm_case_node_t *) node, &location, ret, popped, scope_node);
8807 return;
8808 case PM_CASE_MATCH_NODE:
8809 // case foo; in bar; end
8810 // ^^^^^^^^^^^^^^^^^^^^^
8811 //
8812 // If you use the `case` keyword to create a case match node, it will
8813 // match against all of the `in` clauses until it finds one that
8814 // matches. If it doesn't find one, it can optionally fall back to an
8815 // `else` clause. If none is present and a match wasn't found, it will
8816 // raise an appropriate error.
8817 pm_compile_case_match_node(iseq, (const pm_case_match_node_t *) node, &location, ret, popped, scope_node);
8818 return;
8819 case PM_CLASS_NODE: {
8820 // class Foo; end
8821 // ^^^^^^^^^^^^^^
8822 const pm_class_node_t *cast = (const pm_class_node_t *) node;
8823
8824 ID class_id = pm_constant_id_lookup(scope_node, cast->name);
8825 VALUE class_name = rb_str_freeze(rb_sprintf("<class:%"PRIsVALUE">", rb_id2str(class_id)));
8826
8827 pm_scope_node_t next_scope_node;
8828 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
8829
8830 const rb_iseq_t *class_iseq = NEW_CHILD_ISEQ(&next_scope_node, class_name, ISEQ_TYPE_CLASS, location.line);
8831 pm_scope_node_destroy(&next_scope_node);
8832
8833 // TODO: Once we merge constant path nodes correctly, fix this flag
8834 const int flags = VM_DEFINECLASS_TYPE_CLASS |
8835 (cast->superclass ? VM_DEFINECLASS_FLAG_HAS_SUPERCLASS : 0) |
8836 pm_compile_class_path(iseq, cast->constant_path, &location, ret, false, scope_node);
8837
8838 if (cast->superclass) {
8839 PM_COMPILE_NOT_POPPED(cast->superclass);
8840 }
8841 else {
8842 PUSH_INSN(ret, location, putnil);
8843 }
8844
8845 {
8846 VALUE operand = ID2SYM(class_id);
8847 PUSH_INSN3(ret, location, defineclass, operand, class_iseq, INT2FIX(flags));
8848 }
8849 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)class_iseq);
8850
8851 if (popped) PUSH_INSN(ret, location, pop);
8852 return;
8853 }
8854 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
8855 // @@foo &&= bar
8856 // ^^^^^^^^^^^^^
8857 const pm_class_variable_and_write_node_t *cast = (const pm_class_variable_and_write_node_t *) node;
8858 LABEL *end_label = NEW_LABEL(location.line);
8859
8860 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8861 VALUE name = ID2SYM(name_id);
8862
8863 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8864 if (!popped) PUSH_INSN(ret, location, dup);
8865
8866 PUSH_INSNL(ret, location, branchunless, end_label);
8867 if (!popped) PUSH_INSN(ret, location, pop);
8868
8869 PM_COMPILE_NOT_POPPED(cast->value);
8870 if (!popped) PUSH_INSN(ret, location, dup);
8871
8872 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8873 PUSH_LABEL(ret, end_label);
8874
8875 return;
8876 }
8877 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
8878 // @@foo += bar
8879 // ^^^^^^^^^^^^
8880 const pm_class_variable_operator_write_node_t *cast = (const pm_class_variable_operator_write_node_t *) node;
8881
8882 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8883 VALUE name = ID2SYM(name_id);
8884
8885 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8886 PM_COMPILE_NOT_POPPED(cast->value);
8887
8888 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
8889 int flags = VM_CALL_ARGS_SIMPLE;
8890 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
8891
8892 if (!popped) PUSH_INSN(ret, location, dup);
8893 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8894
8895 return;
8896 }
8897 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
8898 // @@foo ||= bar
8899 // ^^^^^^^^^^^^^
8900 const pm_class_variable_or_write_node_t *cast = (const pm_class_variable_or_write_node_t *) node;
8901 LABEL *end_label = NEW_LABEL(location.line);
8902 LABEL *start_label = NEW_LABEL(location.line);
8903
8904 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8905 VALUE name = ID2SYM(name_id);
8906
8907 PUSH_INSN(ret, location, putnil);
8908 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CVAR), name, Qtrue);
8909 PUSH_INSNL(ret, location, branchunless, start_label);
8910
8911 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8912 if (!popped) PUSH_INSN(ret, location, dup);
8913
8914 PUSH_INSNL(ret, location, branchif, end_label);
8915 if (!popped) PUSH_INSN(ret, location, pop);
8916
8917 PUSH_LABEL(ret, start_label);
8918 PM_COMPILE_NOT_POPPED(cast->value);
8919 if (!popped) PUSH_INSN(ret, location, dup);
8920
8921 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8922 PUSH_LABEL(ret, end_label);
8923
8924 return;
8925 }
8926 case PM_CLASS_VARIABLE_READ_NODE: {
8927 // @@foo
8928 // ^^^^^
8929 if (!popped) {
8930 const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
8931 ID name = pm_constant_id_lookup(scope_node, cast->name);
8932 PUSH_INSN2(ret, location, getclassvariable, ID2SYM(name), get_cvar_ic_value(iseq, name));
8933 }
8934 return;
8935 }
8936 case PM_CLASS_VARIABLE_WRITE_NODE: {
8937 // @@foo = 1
8938 // ^^^^^^^^^
8939 const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
8940 PM_COMPILE_NOT_POPPED(cast->value);
8941 if (!popped) PUSH_INSN(ret, location, dup);
8942
8943 ID name = pm_constant_id_lookup(scope_node, cast->name);
8944 PUSH_INSN2(ret, location, setclassvariable, ID2SYM(name), get_cvar_ic_value(iseq, name));
8945
8946 return;
8947 }
8948 case PM_CONSTANT_PATH_NODE: {
8949 // Foo::Bar
8950 // ^^^^^^^^
8951 VALUE parts;
8952
8953 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache && ((parts = pm_constant_path_parts(node, scope_node)) != Qnil)) {
8954 ISEQ_BODY(iseq)->ic_size++;
8955 PUSH_INSN1(ret, location, opt_getconstant_path, parts);
8956 }
8957 else {
8958 DECL_ANCHOR(prefix);
8959 DECL_ANCHOR(body);
8960
8961 pm_compile_constant_path(iseq, node, prefix, body, popped, scope_node);
8962 if (LIST_INSN_SIZE_ZERO(prefix)) {
8963 PUSH_INSN(ret, location, putnil);
8964 }
8965 else {
8966 PUSH_SEQ(ret, prefix);
8967 }
8968
8969 PUSH_SEQ(ret, body);
8970 }
8971
8972 if (popped) PUSH_INSN(ret, location, pop);
8973 return;
8974 }
8975 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
8976 // Foo::Bar &&= baz
8977 // ^^^^^^^^^^^^^^^^
8978 const pm_constant_path_and_write_node_t *cast = (const pm_constant_path_and_write_node_t *) node;
8979 pm_compile_constant_path_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8980 return;
8981 }
8982 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
8983 // Foo::Bar ||= baz
8984 // ^^^^^^^^^^^^^^^^
8985 const pm_constant_path_or_write_node_t *cast = (const pm_constant_path_or_write_node_t *) node;
8986 pm_compile_constant_path_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8987 return;
8988 }
8989 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
8990 // Foo::Bar += baz
8991 // ^^^^^^^^^^^^^^^
8992 const pm_constant_path_operator_write_node_t *cast = (const pm_constant_path_operator_write_node_t *) node;
8993 pm_compile_constant_path_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8994 return;
8995 }
8996 case PM_CONSTANT_PATH_WRITE_NODE: {
8997 // Foo::Bar = 1
8998 // ^^^^^^^^^^^^
8999 const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
9000 pm_compile_constant_path_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9001 return;
9002 }
9003 case PM_CONSTANT_READ_NODE: {
9004 // Foo
9005 // ^^^
9006 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
9007 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9008
9009 pm_compile_constant_read(iseq, name, &cast->base.location, location.node_id, ret, scope_node);
9010 if (popped) PUSH_INSN(ret, location, pop);
9011
9012 return;
9013 }
9014 case PM_CONSTANT_AND_WRITE_NODE: {
9015 // Foo &&= bar
9016 // ^^^^^^^^^^^
9017 const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
9018 pm_compile_constant_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9019 return;
9020 }
9021 case PM_CONSTANT_OR_WRITE_NODE: {
9022 // Foo ||= bar
9023 // ^^^^^^^^^^^
9024 const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
9025 pm_compile_constant_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9026 return;
9027 }
9028 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
9029 // Foo += bar
9030 // ^^^^^^^^^^
9031 const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
9032 pm_compile_constant_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9033 return;
9034 }
9035 case PM_CONSTANT_WRITE_NODE: {
9036 // Foo = 1
9037 // ^^^^^^^
9038 const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
9039 pm_compile_constant_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9040 return;
9041 }
9042 case PM_DEF_NODE: {
9043 // def foo; end
9044 // ^^^^^^^^^^^^
9045 //
9046 // def self.foo; end
9047 // ^^^^^^^^^^^^^^^^^
9048 const pm_def_node_t *cast = (const pm_def_node_t *) node;
9049 ID method_name = pm_constant_id_lookup(scope_node, cast->name);
9050
9051 pm_scope_node_t next_scope_node;
9052 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9053
9054 rb_iseq_t *method_iseq = NEW_ISEQ(&next_scope_node, rb_id2str(method_name), ISEQ_TYPE_METHOD, location.line);
9055 pm_scope_node_destroy(&next_scope_node);
9056
9057 if (cast->receiver) {
9058 PM_COMPILE_NOT_POPPED(cast->receiver);
9059 PUSH_INSN2(ret, location, definesmethod, ID2SYM(method_name), method_iseq);
9060 }
9061 else {
9062 PUSH_INSN2(ret, location, definemethod, ID2SYM(method_name), method_iseq);
9063 }
9064 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) method_iseq);
9065
9066 if (!popped) {
9067 PUSH_INSN1(ret, location, putobject, ID2SYM(method_name));
9068 }
9069
9070 return;
9071 }
9072 case PM_DEFINED_NODE: {
9073 // defined?(a)
9074 // ^^^^^^^^^^^
9075 const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
9076 pm_compile_defined_expr(iseq, cast->value, &location, ret, popped, scope_node, false);
9077 return;
9078 }
9079 case PM_EMBEDDED_STATEMENTS_NODE: {
9080 // "foo #{bar}"
9081 // ^^^^^^
9082 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
9083
9084 if (cast->statements != NULL) {
9085 PM_COMPILE((const pm_node_t *) (cast->statements));
9086 }
9087 else {
9088 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9089 }
9090
9091 if (popped) PUSH_INSN(ret, location, pop);
9092 return;
9093 }
9094 case PM_EMBEDDED_VARIABLE_NODE: {
9095 // "foo #@bar"
9096 // ^^^^^
9097 const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
9098 PM_COMPILE(cast->variable);
9099 return;
9100 }
9101 case PM_FALSE_NODE: {
9102 // false
9103 // ^^^^^
9104 if (!popped) {
9105 PUSH_INSN1(ret, location, putobject, Qfalse);
9106 }
9107 return;
9108 }
9109 case PM_ENSURE_NODE: {
9110 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
9111
9112 if (cast->statements != NULL) {
9113 PM_COMPILE((const pm_node_t *) cast->statements);
9114 }
9115
9116 return;
9117 }
9118 case PM_ELSE_NODE: {
9119 // if foo then bar else baz end
9120 // ^^^^^^^^^^^^
9121 const pm_else_node_t *cast = (const pm_else_node_t *) node;
9122
9123 if (cast->statements != NULL) {
9124 PM_COMPILE((const pm_node_t *) cast->statements);
9125 }
9126 else if (!popped) {
9127 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9128 }
9129
9130 return;
9131 }
9132 case PM_FLIP_FLOP_NODE: {
9133 // if foo .. bar; end
9134 // ^^^^^^^^^^
9135 const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
9136
9137 LABEL *final_label = NEW_LABEL(location.line);
9138 LABEL *then_label = NEW_LABEL(location.line);
9139 LABEL *else_label = NEW_LABEL(location.line);
9140
9141 pm_compile_flip_flop(cast, else_label, then_label, iseq, location.line, ret, popped, scope_node);
9142
9143 PUSH_LABEL(ret, then_label);
9144 PUSH_INSN1(ret, location, putobject, Qtrue);
9145 PUSH_INSNL(ret, location, jump, final_label);
9146 PUSH_LABEL(ret, else_label);
9147 PUSH_INSN1(ret, location, putobject, Qfalse);
9148 PUSH_LABEL(ret, final_label);
9149
9150 return;
9151 }
9152 case PM_FLOAT_NODE: {
9153 // 1.0
9154 // ^^^
9155 if (!popped) {
9156 VALUE operand = parse_float((const pm_float_node_t *) node);
9157 PUSH_INSN1(ret, location, putobject, operand);
9158 }
9159 return;
9160 }
9161 case PM_FOR_NODE: {
9162 // for foo in bar do end
9163 // ^^^^^^^^^^^^^^^^^^^^^
9164 const pm_for_node_t *cast = (const pm_for_node_t *) node;
9165
9166 LABEL *retry_label = NEW_LABEL(location.line);
9167 LABEL *retry_end_l = NEW_LABEL(location.line);
9168
9169 // First, compile the collection that we're going to be iterating over.
9170 PUSH_LABEL(ret, retry_label);
9171 PM_COMPILE_NOT_POPPED(cast->collection);
9172
9173 // Next, create the new scope that is going to contain the block that
9174 // will be passed to the each method.
9175 pm_scope_node_t next_scope_node;
9176 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9177
9178 const rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location.line);
9179 pm_scope_node_destroy(&next_scope_node);
9180
9181 const rb_iseq_t *prev_block = ISEQ_COMPILE_DATA(iseq)->current_block;
9182 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
9183
9184 // Now, create the method call to each that will be used to iterate over
9185 // the collection, and pass the newly created iseq as the block.
9186 PUSH_SEND_WITH_BLOCK(ret, location, idEach, INT2FIX(0), child_iseq);
9187 pm_compile_retry_end_label(iseq, ret, retry_end_l);
9188
9189 if (popped) PUSH_INSN(ret, location, pop);
9190 ISEQ_COMPILE_DATA(iseq)->current_block = prev_block;
9191 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, child_iseq, retry_end_l);
9192 return;
9193 }
9194 case PM_FORWARDING_ARGUMENTS_NODE:
9195 rb_bug("Cannot compile a ForwardingArgumentsNode directly\n");
9196 return;
9197 case PM_FORWARDING_SUPER_NODE:
9198 // super
9199 // ^^^^^
9200 //
9201 // super {}
9202 // ^^^^^^^^
9203 pm_compile_forwarding_super_node(iseq, (const pm_forwarding_super_node_t *) node, &location, ret, popped, scope_node);
9204 return;
9205 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
9206 // $foo &&= bar
9207 // ^^^^^^^^^^^^
9208 const pm_global_variable_and_write_node_t *cast = (const pm_global_variable_and_write_node_t *) node;
9209 LABEL *end_label = NEW_LABEL(location.line);
9210
9211 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9212 PUSH_INSN1(ret, location, getglobal, name);
9213 if (!popped) PUSH_INSN(ret, location, dup);
9214
9215 PUSH_INSNL(ret, location, branchunless, end_label);
9216 if (!popped) PUSH_INSN(ret, location, pop);
9217
9218 PM_COMPILE_NOT_POPPED(cast->value);
9219 if (!popped) PUSH_INSN(ret, location, dup);
9220
9221 PUSH_INSN1(ret, location, setglobal, name);
9222 PUSH_LABEL(ret, end_label);
9223
9224 return;
9225 }
9226 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
9227 // $foo += bar
9228 // ^^^^^^^^^^^
9229 const pm_global_variable_operator_write_node_t *cast = (const pm_global_variable_operator_write_node_t *) node;
9230
9231 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9232 PUSH_INSN1(ret, location, getglobal, name);
9233 PM_COMPILE_NOT_POPPED(cast->value);
9234
9235 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9236 int flags = VM_CALL_ARGS_SIMPLE;
9237 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
9238
9239 if (!popped) PUSH_INSN(ret, location, dup);
9240 PUSH_INSN1(ret, location, setglobal, name);
9241
9242 return;
9243 }
9244 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
9245 // $foo ||= bar
9246 // ^^^^^^^^^^^^
9247 const pm_global_variable_or_write_node_t *cast = (const pm_global_variable_or_write_node_t *) node;
9248 LABEL *set_label = NEW_LABEL(location.line);
9249 LABEL *end_label = NEW_LABEL(location.line);
9250
9251 PUSH_INSN(ret, location, putnil);
9252 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9253
9254 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_GVAR), name, Qtrue);
9255 PUSH_INSNL(ret, location, branchunless, set_label);
9256
9257 PUSH_INSN1(ret, location, getglobal, name);
9258 if (!popped) PUSH_INSN(ret, location, dup);
9259
9260 PUSH_INSNL(ret, location, branchif, end_label);
9261 if (!popped) PUSH_INSN(ret, location, pop);
9262
9263 PUSH_LABEL(ret, set_label);
9264 PM_COMPILE_NOT_POPPED(cast->value);
9265 if (!popped) PUSH_INSN(ret, location, dup);
9266
9267 PUSH_INSN1(ret, location, setglobal, name);
9268 PUSH_LABEL(ret, end_label);
9269
9270 return;
9271 }
9272 case PM_GLOBAL_VARIABLE_READ_NODE: {
9273 // $foo
9274 // ^^^^
9275 const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
9276 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9277
9278 PUSH_INSN1(ret, location, getglobal, name);
9279 if (popped) PUSH_INSN(ret, location, pop);
9280
9281 return;
9282 }
9283 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
9284 // $foo = 1
9285 // ^^^^^^^^
9286 const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
9287 PM_COMPILE_NOT_POPPED(cast->value);
9288 if (!popped) PUSH_INSN(ret, location, dup);
9289
9290 ID name = pm_constant_id_lookup(scope_node, cast->name);
9291 PUSH_INSN1(ret, location, setglobal, ID2SYM(name));
9292
9293 return;
9294 }
9295 case PM_HASH_NODE: {
9296 // {}
9297 // ^^
9298 //
9299 // If every node in the hash is static, then we can compile the entire
9300 // hash now instead of later.
9301 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9302 // We're only going to compile this node if it's not popped. If it
9303 // is popped, then we know we don't need to do anything since it's
9304 // statically known.
9305 if (!popped) {
9306 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
9307
9308 if (cast->elements.size == 0) {
9309 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
9310 }
9311 else {
9312 VALUE value = pm_static_literal_value(iseq, node, scope_node);
9313 PUSH_INSN1(ret, location, duphash, value);
9314 RB_OBJ_WRITTEN(iseq, Qundef, value);
9315 }
9316 }
9317 }
9318 else {
9319 // Here since we know there are possible side-effects inside the
9320 // hash contents, we're going to build it entirely at runtime. We'll
9321 // do this by pushing all of the key-value pairs onto the stack and
9322 // then combining them with newhash.
9323 //
9324 // If this hash is popped, then this serves only to ensure we enact
9325 // all side-effects (like method calls) that are contained within
9326 // the hash contents.
9327 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
9328 const pm_node_list_t *elements = &cast->elements;
9329
9330 if (popped) {
9331 // If this hash is popped, then we can iterate through each
9332 // element and compile it. The result of each compilation will
9333 // only include the side effects of the element itself.
9334 for (size_t index = 0; index < elements->size; index++) {
9335 PM_COMPILE_POPPED(elements->nodes[index]);
9336 }
9337 }
9338 else {
9339 pm_compile_hash_elements(iseq, node, elements, 0, Qundef, false, ret, scope_node);
9340 }
9341 }
9342
9343 return;
9344 }
9345 case PM_IF_NODE: {
9346 // if foo then bar end
9347 // ^^^^^^^^^^^^^^^^^^^
9348 //
9349 // bar if foo
9350 // ^^^^^^^^^^
9351 //
9352 // foo ? bar : baz
9353 // ^^^^^^^^^^^^^^^
9354 const pm_if_node_t *cast = (const pm_if_node_t *) node;
9355 pm_compile_conditional(iseq, &location, PM_IF_NODE, (const pm_node_t *) cast, cast->statements, cast->subsequent, cast->predicate, ret, popped, scope_node);
9356 return;
9357 }
9358 case PM_IMAGINARY_NODE: {
9359 // 1i
9360 // ^^
9361 if (!popped) {
9362 VALUE operand = parse_imaginary((const pm_imaginary_node_t *) node);
9363 PUSH_INSN1(ret, location, putobject, operand);
9364 }
9365 return;
9366 }
9367 case PM_IMPLICIT_NODE: {
9368 // Implicit nodes mark places in the syntax tree where explicit syntax
9369 // was omitted, but implied. For example,
9370 //
9371 // { foo: }
9372 //
9373 // In this case a method call/local variable read is implied by virtue
9374 // of the missing value. To compile these nodes, we simply compile the
9375 // value that is implied, which is helpfully supplied by the parser.
9376 const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
9377 PM_COMPILE(cast->value);
9378 return;
9379 }
9380 case PM_IN_NODE: {
9381 // In nodes are handled by the case match node directly, so we should
9382 // never end up hitting them through this path.
9383 rb_bug("Should not ever enter an in node directly");
9384 return;
9385 }
9386 case PM_INDEX_OPERATOR_WRITE_NODE: {
9387 // foo[bar] += baz
9388 // ^^^^^^^^^^^^^^^
9389 const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
9390 pm_compile_index_operator_write_node(iseq, cast, &location, ret, popped, scope_node);
9391 return;
9392 }
9393 case PM_INDEX_AND_WRITE_NODE: {
9394 // foo[bar] &&= baz
9395 // ^^^^^^^^^^^^^^^^
9396 const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
9397 pm_compile_index_control_flow_write_node(iseq, node, cast->receiver, cast->arguments, cast->block, cast->value, &location, ret, popped, scope_node);
9398 return;
9399 }
9400 case PM_INDEX_OR_WRITE_NODE: {
9401 // foo[bar] ||= baz
9402 // ^^^^^^^^^^^^^^^^
9403 const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
9404 pm_compile_index_control_flow_write_node(iseq, node, cast->receiver, cast->arguments, cast->block, cast->value, &location, ret, popped, scope_node);
9405 return;
9406 }
9407 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
9408 // @foo &&= bar
9409 // ^^^^^^^^^^^^
9410 const pm_instance_variable_and_write_node_t *cast = (const pm_instance_variable_and_write_node_t *) node;
9411 LABEL *end_label = NEW_LABEL(location.line);
9412
9413 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9414 VALUE name = ID2SYM(name_id);
9415
9416 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9417 if (!popped) PUSH_INSN(ret, location, dup);
9418
9419 PUSH_INSNL(ret, location, branchunless, end_label);
9420 if (!popped) PUSH_INSN(ret, location, pop);
9421
9422 PM_COMPILE_NOT_POPPED(cast->value);
9423 if (!popped) PUSH_INSN(ret, location, dup);
9424
9425 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9426 PUSH_LABEL(ret, end_label);
9427
9428 return;
9429 }
9430 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
9431 // @foo += bar
9432 // ^^^^^^^^^^^
9433 const pm_instance_variable_operator_write_node_t *cast = (const pm_instance_variable_operator_write_node_t *) node;
9434
9435 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9436 VALUE name = ID2SYM(name_id);
9437
9438 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9439 PM_COMPILE_NOT_POPPED(cast->value);
9440
9441 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9442 int flags = VM_CALL_ARGS_SIMPLE;
9443 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
9444
9445 if (!popped) PUSH_INSN(ret, location, dup);
9446 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9447
9448 return;
9449 }
9450 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
9451 // @foo ||= bar
9452 // ^^^^^^^^^^^^
9453 const pm_instance_variable_or_write_node_t *cast = (const pm_instance_variable_or_write_node_t *) node;
9454 LABEL *end_label = NEW_LABEL(location.line);
9455
9456 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9457 VALUE name = ID2SYM(name_id);
9458
9459 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9460 if (!popped) PUSH_INSN(ret, location, dup);
9461
9462 PUSH_INSNL(ret, location, branchif, end_label);
9463 if (!popped) PUSH_INSN(ret, location, pop);
9464
9465 PM_COMPILE_NOT_POPPED(cast->value);
9466 if (!popped) PUSH_INSN(ret, location, dup);
9467
9468 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9469 PUSH_LABEL(ret, end_label);
9470
9471 return;
9472 }
9473 case PM_INSTANCE_VARIABLE_READ_NODE: {
9474 // @foo
9475 // ^^^^
9476 if (!popped) {
9477 const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
9478 ID name = pm_constant_id_lookup(scope_node, cast->name);
9479 PUSH_INSN2(ret, location, getinstancevariable, ID2SYM(name), get_ivar_ic_value(iseq, name));
9480 }
9481 return;
9482 }
9483 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
9484 // @foo = 1
9485 // ^^^^^^^^
9486 const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
9487 PM_COMPILE_NOT_POPPED(cast->value);
9488 if (!popped) PUSH_INSN(ret, location, dup);
9489
9490 ID name = pm_constant_id_lookup(scope_node, cast->name);
9491 PUSH_INSN2(ret, location, setinstancevariable, ID2SYM(name), get_ivar_ic_value(iseq, name));
9492
9493 return;
9494 }
9495 case PM_INTEGER_NODE: {
9496 // 1
9497 // ^
9498 if (!popped) {
9499 VALUE operand = parse_integer((const pm_integer_node_t *) node);
9500 PUSH_INSN1(ret, location, putobject, operand);
9501 }
9502 return;
9503 }
9504 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
9505 // if /foo #{bar}/ then end
9506 // ^^^^^^^^^^^^
9507 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9508 if (!popped) {
9509 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9510 PUSH_INSN1(ret, location, putobject, regexp);
9511 }
9512 }
9513 else {
9514 pm_compile_regexp_dynamic(iseq, node, &((const pm_interpolated_match_last_line_node_t *) node)->parts, &location, ret, popped, scope_node);
9515 }
9516
9517 PUSH_INSN1(ret, location, getglobal, rb_id2sym(idLASTLINE));
9518 PUSH_SEND(ret, location, idEqTilde, INT2NUM(1));
9519 if (popped) PUSH_INSN(ret, location, pop);
9520
9521 return;
9522 }
9523 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
9524 // /foo #{bar}/
9525 // ^^^^^^^^^^^^
9526 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
9527 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
9528 const rb_iseq_t *block_iseq = NULL;
9529 int ise_index = ISEQ_BODY(iseq)->ise_size++;
9530
9531 pm_scope_node_t next_scope_node;
9532 pm_scope_node_init(node, &next_scope_node, scope_node);
9533
9534 block_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_PLAIN, location.line);
9535 pm_scope_node_destroy(&next_scope_node);
9536
9537 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
9538 PUSH_INSN2(ret, location, once, block_iseq, INT2FIX(ise_index));
9539 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
9540
9541 if (popped) PUSH_INSN(ret, location, pop);
9542 return;
9543 }
9544
9545 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9546 if (!popped) {
9547 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9548 PUSH_INSN1(ret, location, putobject, regexp);
9549 }
9550 }
9551 else {
9552 pm_compile_regexp_dynamic(iseq, node, &((const pm_interpolated_regular_expression_node_t *) node)->parts, &location, ret, popped, scope_node);
9553 if (popped) PUSH_INSN(ret, location, pop);
9554 }
9555
9556 return;
9557 }
9558 case PM_INTERPOLATED_STRING_NODE: {
9559 // "foo #{bar}"
9560 // ^^^^^^^^^^^^
9561 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9562 if (!popped) {
9563 VALUE string = pm_static_literal_value(iseq, node, scope_node);
9564
9565 if (PM_NODE_FLAG_P(node, PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN)) {
9566 PUSH_INSN1(ret, location, putobject, string);
9567 }
9568 else if (PM_NODE_FLAG_P(node, PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE)) {
9569 PUSH_INSN1(ret, location, putstring, string);
9570 }
9571 else {
9572 PUSH_INSN1(ret, location, putchilledstring, string);
9573 }
9574 }
9575 }
9576 else {
9577 const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
9578 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, popped, scope_node, NULL, NULL);
9579 if (length > 1) PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9580 if (popped) PUSH_INSN(ret, location, pop);
9581 }
9582
9583 return;
9584 }
9585 case PM_INTERPOLATED_SYMBOL_NODE: {
9586 // :"foo #{bar}"
9587 // ^^^^^^^^^^^^^
9588 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
9589 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, popped, scope_node, NULL, NULL);
9590
9591 if (length > 1) {
9592 PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9593 }
9594
9595 if (!popped) {
9596 PUSH_INSN(ret, location, intern);
9597 }
9598 else {
9599 PUSH_INSN(ret, location, pop);
9600 }
9601
9602 return;
9603 }
9604 case PM_INTERPOLATED_X_STRING_NODE: {
9605 // `foo #{bar}`
9606 // ^^^^^^^^^^^^
9607 const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
9608
9609 PUSH_INSN(ret, location, putself);
9610
9611 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, false, scope_node, NULL, NULL);
9612 if (length > 1) PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9613
9614 PUSH_SEND_WITH_FLAG(ret, location, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
9615 if (popped) PUSH_INSN(ret, location, pop);
9616
9617 return;
9618 }
9619 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
9620 // -> { it }
9621 // ^^
9622 if (!popped) {
9623 pm_scope_node_t *current_scope_node = scope_node;
9624 int level = 0;
9625
9626 while (current_scope_node) {
9627 if (current_scope_node->parameters && PM_NODE_TYPE_P(current_scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
9628 PUSH_GETLOCAL(ret, location, current_scope_node->local_table_for_iseq_size, level);
9629 return;
9630 }
9631
9632 current_scope_node = current_scope_node->previous;
9633 level++;
9634 }
9635 rb_bug("Local `it` does not exist");
9636 }
9637
9638 return;
9639 }
9640 case PM_KEYWORD_HASH_NODE: {
9641 // foo(bar: baz)
9642 // ^^^^^^^^
9643 const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
9644 const pm_node_list_t *elements = &cast->elements;
9645
9646 const pm_node_t *element;
9647 PM_NODE_LIST_FOREACH(elements, index, element) {
9648 PM_COMPILE(element);
9649 }
9650
9651 if (!popped) PUSH_INSN1(ret, location, newhash, INT2FIX(elements->size * 2));
9652 return;
9653 }
9654 case PM_LAMBDA_NODE: {
9655 // -> {}
9656 // ^^^^^
9657 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
9658
9659 pm_scope_node_t next_scope_node;
9660 pm_scope_node_init(node, &next_scope_node, scope_node);
9661
9662 int opening_lineno = pm_location_line_number(parser, &cast->opening_loc);
9663 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, opening_lineno);
9664 pm_scope_node_destroy(&next_scope_node);
9665
9666 VALUE argc = INT2FIX(0);
9667 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
9668 PUSH_CALL_WITH_BLOCK(ret, location, idLambda, argc, block);
9669 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) block);
9670
9671 if (popped) PUSH_INSN(ret, location, pop);
9672 return;
9673 }
9674 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
9675 // foo &&= bar
9676 // ^^^^^^^^^^^
9677 const pm_local_variable_and_write_node_t *cast = (const pm_local_variable_and_write_node_t *) node;
9678 LABEL *end_label = NEW_LABEL(location.line);
9679
9680 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9681 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9682 if (!popped) PUSH_INSN(ret, location, dup);
9683
9684 PUSH_INSNL(ret, location, branchunless, end_label);
9685 if (!popped) PUSH_INSN(ret, location, pop);
9686
9687 PM_COMPILE_NOT_POPPED(cast->value);
9688 if (!popped) PUSH_INSN(ret, location, dup);
9689
9690 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9691 PUSH_LABEL(ret, end_label);
9692
9693 return;
9694 }
9695 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
9696 // foo += bar
9697 // ^^^^^^^^^^
9698 const pm_local_variable_operator_write_node_t *cast = (const pm_local_variable_operator_write_node_t *) node;
9699
9700 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9701 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9702
9703 PM_COMPILE_NOT_POPPED(cast->value);
9704
9705 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9706 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
9707
9708 if (!popped) PUSH_INSN(ret, location, dup);
9709 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9710
9711 return;
9712 }
9713 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
9714 // foo ||= bar
9715 // ^^^^^^^^^^^
9716 const pm_local_variable_or_write_node_t *cast = (const pm_local_variable_or_write_node_t *) node;
9717
9718 LABEL *set_label = NEW_LABEL(location.line);
9719 LABEL *end_label = NEW_LABEL(location.line);
9720
9721 PUSH_INSN1(ret, location, putobject, Qtrue);
9722 PUSH_INSNL(ret, location, branchunless, set_label);
9723
9724 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9725 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9726 if (!popped) PUSH_INSN(ret, location, dup);
9727
9728 PUSH_INSNL(ret, location, branchif, end_label);
9729 if (!popped) PUSH_INSN(ret, location, pop);
9730
9731 PUSH_LABEL(ret, set_label);
9732 PM_COMPILE_NOT_POPPED(cast->value);
9733 if (!popped) PUSH_INSN(ret, location, dup);
9734
9735 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9736 PUSH_LABEL(ret, end_label);
9737
9738 return;
9739 }
9740 case PM_LOCAL_VARIABLE_READ_NODE: {
9741 // foo
9742 // ^^^
9743 if (!popped) {
9744 const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) node;
9745 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9746 PUSH_GETLOCAL(ret, location, index.index, index.level);
9747 }
9748
9749 return;
9750 }
9751 case PM_LOCAL_VARIABLE_WRITE_NODE: {
9752 // foo = 1
9753 // ^^^^^^^
9754 const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
9755 PM_COMPILE_NOT_POPPED(cast->value);
9756 if (!popped) PUSH_INSN(ret, location, dup);
9757
9758 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9759 PUSH_SETLOCAL(ret, location, index.index, index.level);
9760 return;
9761 }
9762 case PM_MATCH_LAST_LINE_NODE: {
9763 // if /foo/ then end
9764 // ^^^^^
9765 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9766
9767 PUSH_INSN1(ret, location, putobject, regexp);
9768 PUSH_INSN2(ret, location, getspecial, INT2FIX(0), INT2FIX(0));
9769 PUSH_SEND(ret, location, idEqTilde, INT2NUM(1));
9770 if (popped) PUSH_INSN(ret, location, pop);
9771
9772 return;
9773 }
9774 case PM_MATCH_PREDICATE_NODE: {
9775 // foo in bar
9776 // ^^^^^^^^^^
9777 const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
9778
9779 // First, allocate some stack space for the cached return value of any
9780 // calls to #deconstruct.
9781 PUSH_INSN(ret, location, putnil);
9782
9783 // Next, compile the expression that we're going to match against.
9784 PM_COMPILE_NOT_POPPED(cast->value);
9785 PUSH_INSN(ret, location, dup);
9786
9787 // Now compile the pattern that is going to be used to match against the
9788 // expression.
9789 LABEL *matched_label = NEW_LABEL(location.line);
9790 LABEL *unmatched_label = NEW_LABEL(location.line);
9791 LABEL *done_label = NEW_LABEL(location.line);
9792 pm_compile_pattern(iseq, scope_node, cast->pattern, ret, matched_label, unmatched_label, false, false, true, 2);
9793
9794 // If the pattern did not match, then compile the necessary instructions
9795 // to handle pushing false onto the stack, then jump to the end.
9796 PUSH_LABEL(ret, unmatched_label);
9797 PUSH_INSN(ret, location, pop);
9798 PUSH_INSN(ret, location, pop);
9799
9800 if (!popped) PUSH_INSN1(ret, location, putobject, Qfalse);
9801 PUSH_INSNL(ret, location, jump, done_label);
9802 PUSH_INSN(ret, location, putnil);
9803
9804 // If the pattern did match, then compile the necessary instructions to
9805 // handle pushing true onto the stack, then jump to the end.
9806 PUSH_LABEL(ret, matched_label);
9807 PUSH_INSN1(ret, location, adjuststack, INT2FIX(2));
9808 if (!popped) PUSH_INSN1(ret, location, putobject, Qtrue);
9809 PUSH_INSNL(ret, location, jump, done_label);
9810
9811 PUSH_LABEL(ret, done_label);
9812 return;
9813 }
9814 case PM_MATCH_REQUIRED_NODE:
9815 // foo => bar
9816 // ^^^^^^^^^^
9817 //
9818 // A match required node represents pattern matching against a single
9819 // pattern using the => operator. For example,
9820 //
9821 // foo => bar
9822 //
9823 // This is somewhat analogous to compiling a case match statement with a
9824 // single pattern. In both cases, if the pattern fails it should
9825 // immediately raise an error.
9826 pm_compile_match_required_node(iseq, (const pm_match_required_node_t *) node, &location, ret, popped, scope_node);
9827 return;
9828 case PM_MATCH_WRITE_NODE:
9829 // /(?<foo>foo)/ =~ bar
9830 // ^^^^^^^^^^^^^^^^^^^^
9831 //
9832 // Match write nodes are specialized call nodes that have a regular
9833 // expression with valid named capture groups on the left, the =~
9834 // operator, and some value on the right. The nodes themselves simply
9835 // wrap the call with the local variable targets that will be written
9836 // when the call is executed.
9837 pm_compile_match_write_node(iseq, (const pm_match_write_node_t *) node, &location, ret, popped, scope_node);
9838 return;
9839 case PM_MISSING_NODE:
9840 rb_bug("A pm_missing_node_t should not exist in prism's AST.");
9841 return;
9842 case PM_MODULE_NODE: {
9843 // module Foo; end
9844 // ^^^^^^^^^^^^^^^
9845 const pm_module_node_t *cast = (const pm_module_node_t *) node;
9846
9847 ID module_id = pm_constant_id_lookup(scope_node, cast->name);
9848 VALUE module_name = rb_str_freeze(rb_sprintf("<module:%"PRIsVALUE">", rb_id2str(module_id)));
9849
9850 pm_scope_node_t next_scope_node;
9851 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9852
9853 const rb_iseq_t *module_iseq = NEW_CHILD_ISEQ(&next_scope_node, module_name, ISEQ_TYPE_CLASS, location.line);
9854 pm_scope_node_destroy(&next_scope_node);
9855
9856 const int flags = VM_DEFINECLASS_TYPE_MODULE | pm_compile_class_path(iseq, cast->constant_path, &location, ret, false, scope_node);
9857 PUSH_INSN(ret, location, putnil);
9858 PUSH_INSN3(ret, location, defineclass, ID2SYM(module_id), module_iseq, INT2FIX(flags));
9859 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) module_iseq);
9860
9861 if (popped) PUSH_INSN(ret, location, pop);
9862 return;
9863 }
9864 case PM_REQUIRED_PARAMETER_NODE: {
9865 // def foo(bar); end
9866 // ^^^
9867 const pm_required_parameter_node_t *cast = (const pm_required_parameter_node_t *) node;
9868 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, 0);
9869
9870 PUSH_SETLOCAL(ret, location, index.index, index.level);
9871 return;
9872 }
9873 case PM_MULTI_WRITE_NODE: {
9874 // foo, bar = baz
9875 // ^^^^^^^^^^^^^^
9876 //
9877 // A multi write node represents writing to multiple values using an =
9878 // operator. Importantly these nodes are only parsed when the left-hand
9879 // side of the operator has multiple targets. The right-hand side of the
9880 // operator having multiple targets represents an implicit array
9881 // instead.
9882 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
9883
9884 DECL_ANCHOR(writes);
9885 DECL_ANCHOR(cleanup);
9886
9887 pm_multi_target_state_t state = { 0 };
9888 state.position = popped ? 0 : 1;
9889 pm_compile_multi_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
9890
9891 PM_COMPILE_NOT_POPPED(cast->value);
9892 if (!popped) PUSH_INSN(ret, location, dup);
9893
9894 PUSH_SEQ(ret, writes);
9895 if (!popped && state.stack_size >= 1) {
9896 // Make sure the value on the right-hand side of the = operator is
9897 // being returned before we pop the parent expressions.
9898 PUSH_INSN1(ret, location, setn, INT2FIX(state.stack_size));
9899 }
9900
9901 // Now, we need to go back and modify the topn instructions in order to
9902 // ensure they can correctly retrieve the parent expressions.
9903 pm_multi_target_state_update(&state);
9904
9905 PUSH_SEQ(ret, cleanup);
9906 return;
9907 }
9908 case PM_NEXT_NODE:
9909 // next
9910 // ^^^^
9911 //
9912 // next foo
9913 // ^^^^^^^^
9914 pm_compile_next_node(iseq, (const pm_next_node_t *) node, &location, ret, popped, scope_node);
9915 return;
9916 case PM_NIL_NODE: {
9917 // nil
9918 // ^^^
9919 if (!popped) {
9920 PUSH_INSN(ret, location, putnil);
9921 }
9922
9923 return;
9924 }
9925 case PM_NO_KEYWORDS_PARAMETER_NODE: {
9926 // def foo(**nil); end
9927 // ^^^^^
9928 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg = TRUE;
9929 return;
9930 }
9931 case PM_NUMBERED_REFERENCE_READ_NODE: {
9932 // $1
9933 // ^^
9934 if (!popped) {
9935 const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
9936
9937 if (cast->number != 0) {
9938 VALUE ref = pm_compile_numbered_reference_ref(cast);
9939 PUSH_INSN2(ret, location, getspecial, INT2FIX(1), ref);
9940 }
9941 else {
9942 PUSH_INSN(ret, location, putnil);
9943 }
9944 }
9945
9946 return;
9947 }
9948 case PM_OR_NODE: {
9949 // a or b
9950 // ^^^^^^
9951 const pm_or_node_t *cast = (const pm_or_node_t *) node;
9952
9953 LABEL *end_label = NEW_LABEL(location.line);
9954 PM_COMPILE_NOT_POPPED(cast->left);
9955
9956 if (!popped) PUSH_INSN(ret, location, dup);
9957 PUSH_INSNL(ret, location, branchif, end_label);
9958
9959 if (!popped) PUSH_INSN(ret, location, pop);
9960 PM_COMPILE(cast->right);
9961 PUSH_LABEL(ret, end_label);
9962
9963 return;
9964 }
9965 case PM_OPTIONAL_PARAMETER_NODE: {
9966 // def foo(bar = 1); end
9967 // ^^^^^^^
9968 const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
9969 PM_COMPILE_NOT_POPPED(cast->value);
9970
9971 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, 0);
9972 PUSH_SETLOCAL(ret, location, index.index, index.level);
9973
9974 return;
9975 }
9976 case PM_PARENTHESES_NODE: {
9977 // ()
9978 // ^^
9979 //
9980 // (1)
9981 // ^^^
9982 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
9983
9984 if (cast->body != NULL) {
9985 PM_COMPILE(cast->body);
9986 }
9987 else if (!popped) {
9988 PUSH_INSN(ret, location, putnil);
9989 }
9990
9991 return;
9992 }
9993 case PM_PRE_EXECUTION_NODE: {
9994 // BEGIN {}
9995 // ^^^^^^^^
9996 const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
9997
9998 LINK_ANCHOR *outer_pre = scope_node->pre_execution_anchor;
9999 RUBY_ASSERT(outer_pre != NULL);
10000
10001 // BEGIN{} nodes can be nested, so here we're going to do the same thing
10002 // that we did for the top-level compilation where we create two
10003 // anchors and then join them in the correct order into the resulting
10004 // anchor.
10005 DECL_ANCHOR(inner_pre);
10006 scope_node->pre_execution_anchor = inner_pre;
10007
10008 DECL_ANCHOR(inner_body);
10009
10010 if (cast->statements != NULL) {
10011 const pm_node_list_t *body = &cast->statements->body;
10012
10013 for (size_t index = 0; index < body->size; index++) {
10014 pm_compile_node(iseq, body->nodes[index], inner_body, true, scope_node);
10015 }
10016 }
10017
10018 if (!popped) {
10019 PUSH_INSN(inner_body, location, putnil);
10020 }
10021
10022 // Now that everything has been compiled, join both anchors together
10023 // into the correct outer pre execution anchor, and reset the value so
10024 // that subsequent BEGIN{} nodes can be compiled correctly.
10025 PUSH_SEQ(outer_pre, inner_pre);
10026 PUSH_SEQ(outer_pre, inner_body);
10027 scope_node->pre_execution_anchor = outer_pre;
10028
10029 return;
10030 }
10031 case PM_POST_EXECUTION_NODE: {
10032 // END {}
10033 // ^^^^^^
10034 const rb_iseq_t *child_iseq;
10035 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
10036
10037 pm_scope_node_t next_scope_node;
10038 pm_scope_node_init(node, &next_scope_node, scope_node);
10039 child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno);
10040 pm_scope_node_destroy(&next_scope_node);
10041
10042 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
10043
10044 int is_index = ISEQ_BODY(iseq)->ise_size++;
10045 PUSH_INSN2(ret, location, once, child_iseq, INT2FIX(is_index));
10046 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) child_iseq);
10047 if (popped) PUSH_INSN(ret, location, pop);
10048
10049 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
10050
10051 return;
10052 }
10053 case PM_RANGE_NODE: {
10054 // 0..5
10055 // ^^^^
10056 const pm_range_node_t *cast = (const pm_range_node_t *) node;
10057 bool exclude_end = PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END);
10058
10059 if (pm_optimizable_range_item_p(cast->left) && pm_optimizable_range_item_p(cast->right)) {
10060 if (!popped) {
10061 const pm_node_t *left = cast->left;
10062 const pm_node_t *right = cast->right;
10063
10064 VALUE val = rb_range_new(
10065 (left && PM_NODE_TYPE_P(left, PM_INTEGER_NODE)) ? parse_integer((const pm_integer_node_t *) left) : Qnil,
10066 (right && PM_NODE_TYPE_P(right, PM_INTEGER_NODE)) ? parse_integer((const pm_integer_node_t *) right) : Qnil,
10067 exclude_end
10068 );
10069
10070 PUSH_INSN1(ret, location, putobject, val);
10071 }
10072 }
10073 else {
10074 if (cast->left != NULL) {
10075 PM_COMPILE(cast->left);
10076 }
10077 else if (!popped) {
10078 PUSH_INSN(ret, location, putnil);
10079 }
10080
10081 if (cast->right != NULL) {
10082 PM_COMPILE(cast->right);
10083 }
10084 else if (!popped) {
10085 PUSH_INSN(ret, location, putnil);
10086 }
10087
10088 if (!popped) {
10089 PUSH_INSN1(ret, location, newrange, INT2FIX(exclude_end ? 1 : 0));
10090 }
10091 }
10092 return;
10093 }
10094 case PM_RATIONAL_NODE: {
10095 // 1r
10096 // ^^
10097 if (!popped) {
10098 PUSH_INSN1(ret, location, putobject, parse_rational((const pm_rational_node_t *) node));
10099 }
10100 return;
10101 }
10102 case PM_REDO_NODE:
10103 // redo
10104 // ^^^^
10105 pm_compile_redo_node(iseq, &location, ret, popped, scope_node);
10106 return;
10107 case PM_REGULAR_EXPRESSION_NODE: {
10108 // /foo/
10109 // ^^^^^
10110 if (!popped) {
10111 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
10112 PUSH_INSN1(ret, location, putobject, regexp);
10113 }
10114 return;
10115 }
10116 case PM_RESCUE_NODE:
10117 // begin; rescue; end
10118 // ^^^^^^^
10119 pm_compile_rescue_node(iseq, (const pm_rescue_node_t *) node, &location, ret, popped, scope_node);
10120 return;
10121 case PM_RESCUE_MODIFIER_NODE: {
10122 // foo rescue bar
10123 // ^^^^^^^^^^^^^^
10124 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
10125
10126 pm_scope_node_t rescue_scope_node;
10127 pm_scope_node_init((const pm_node_t *) cast, &rescue_scope_node, scope_node);
10128
10129 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
10130 &rescue_scope_node,
10131 rb_str_concat(rb_str_new2("rescue in "), ISEQ_BODY(iseq)->location.label),
10132 ISEQ_TYPE_RESCUE,
10133 pm_node_line_number(parser, cast->rescue_expression)
10134 );
10135
10136 pm_scope_node_destroy(&rescue_scope_node);
10137
10138 LABEL *lstart = NEW_LABEL(location.line);
10139 LABEL *lend = NEW_LABEL(location.line);
10140 LABEL *lcont = NEW_LABEL(location.line);
10141
10142 lstart->rescued = LABEL_RESCUE_BEG;
10143 lend->rescued = LABEL_RESCUE_END;
10144
10145 PUSH_LABEL(ret, lstart);
10146 PM_COMPILE_NOT_POPPED(cast->expression);
10147 PUSH_LABEL(ret, lend);
10148
10149 PUSH_INSN(ret, location, nop);
10150 PUSH_LABEL(ret, lcont);
10151 if (popped) PUSH_INSN(ret, location, pop);
10152
10153 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
10154 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
10155 return;
10156 }
10157 case PM_RETURN_NODE:
10158 // return
10159 // ^^^^^^
10160 //
10161 // return 1
10162 // ^^^^^^^^
10163 pm_compile_return_node(iseq, (const pm_return_node_t *) node, &location, ret, popped, scope_node);
10164 return;
10165 case PM_RETRY_NODE: {
10166 // retry
10167 // ^^^^^
10168 if (ISEQ_BODY(iseq)->type == ISEQ_TYPE_RESCUE) {
10169 PUSH_INSN(ret, location, putnil);
10170 PUSH_INSN1(ret, location, throw, INT2FIX(TAG_RETRY));
10171 if (popped) PUSH_INSN(ret, location, pop);
10172 }
10173 else {
10174 COMPILE_ERROR(iseq, location.line, "Invalid retry");
10175 return;
10176 }
10177 return;
10178 }
10179 case PM_SCOPE_NODE:
10180 pm_compile_scope_node(iseq, (pm_scope_node_t *) node, &location, ret, popped);
10181 return;
10182 case PM_SELF_NODE: {
10183 // self
10184 // ^^^^
10185 if (!popped) {
10186 PUSH_INSN(ret, location, putself);
10187 }
10188 return;
10189 }
10190 case PM_SHAREABLE_CONSTANT_NODE: {
10191 // A value that is being written to a constant that is being marked as
10192 // shared depending on the current lexical context.
10193 const pm_shareable_constant_node_t *cast = (const pm_shareable_constant_node_t *) node;
10194 pm_node_flags_t shareability = (cast->base.flags & (PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL | PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING | PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY));
10195
10196 switch (PM_NODE_TYPE(cast->write)) {
10197 case PM_CONSTANT_WRITE_NODE:
10198 pm_compile_constant_write_node(iseq, (const pm_constant_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10199 break;
10200 case PM_CONSTANT_AND_WRITE_NODE:
10201 pm_compile_constant_and_write_node(iseq, (const pm_constant_and_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10202 break;
10203 case PM_CONSTANT_OR_WRITE_NODE:
10204 pm_compile_constant_or_write_node(iseq, (const pm_constant_or_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10205 break;
10206 case PM_CONSTANT_OPERATOR_WRITE_NODE:
10207 pm_compile_constant_operator_write_node(iseq, (const pm_constant_operator_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10208 break;
10209 case PM_CONSTANT_PATH_WRITE_NODE:
10210 pm_compile_constant_path_write_node(iseq, (const pm_constant_path_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10211 break;
10212 case PM_CONSTANT_PATH_AND_WRITE_NODE:
10213 pm_compile_constant_path_and_write_node(iseq, (const pm_constant_path_and_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10214 break;
10215 case PM_CONSTANT_PATH_OR_WRITE_NODE:
10216 pm_compile_constant_path_or_write_node(iseq, (const pm_constant_path_or_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10217 break;
10218 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE:
10219 pm_compile_constant_path_operator_write_node(iseq, (const pm_constant_path_operator_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10220 break;
10221 default:
10222 rb_bug("Unexpected node type for shareable constant write: %s", pm_node_type_to_str(PM_NODE_TYPE(cast->write)));
10223 break;
10224 }
10225
10226 return;
10227 }
10228 case PM_SINGLETON_CLASS_NODE: {
10229 // class << self; end
10230 // ^^^^^^^^^^^^^^^^^^
10231 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
10232
10233 pm_scope_node_t next_scope_node;
10234 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
10235 const rb_iseq_t *child_iseq = NEW_ISEQ(&next_scope_node, rb_fstring_lit("singleton class"), ISEQ_TYPE_CLASS, location.line);
10236 pm_scope_node_destroy(&next_scope_node);
10237
10238 PM_COMPILE_NOT_POPPED(cast->expression);
10239 PUSH_INSN(ret, location, putnil);
10240
10241 ID singletonclass;
10242 CONST_ID(singletonclass, "singletonclass");
10243 PUSH_INSN3(ret, location, defineclass, ID2SYM(singletonclass), child_iseq, INT2FIX(VM_DEFINECLASS_TYPE_SINGLETON_CLASS));
10244
10245 if (popped) PUSH_INSN(ret, location, pop);
10246 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) child_iseq);
10247
10248 return;
10249 }
10250 case PM_SOURCE_ENCODING_NODE: {
10251 // __ENCODING__
10252 // ^^^^^^^^^^^^
10253 if (!popped) {
10254 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10255 PUSH_INSN1(ret, location, putobject, value);
10256 }
10257 return;
10258 }
10259 case PM_SOURCE_FILE_NODE: {
10260 // __FILE__
10261 // ^^^^^^^^
10262 if (!popped) {
10263 const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
10264 VALUE string = pm_source_file_value(cast, scope_node);
10265
10266 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
10267 PUSH_INSN1(ret, location, putobject, string);
10268 }
10269 else if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
10270 PUSH_INSN1(ret, location, putstring, string);
10271 }
10272 else {
10273 PUSH_INSN1(ret, location, putchilledstring, string);
10274 }
10275 }
10276 return;
10277 }
10278 case PM_SOURCE_LINE_NODE: {
10279 // __LINE__
10280 // ^^^^^^^^
10281 if (!popped) {
10282 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10283 PUSH_INSN1(ret, location, putobject, value);
10284 }
10285 return;
10286 }
10287 case PM_SPLAT_NODE: {
10288 // foo(*bar)
10289 // ^^^^
10290 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
10291 if (cast->expression) {
10292 PM_COMPILE(cast->expression);
10293 }
10294
10295 if (!popped) {
10296 PUSH_INSN1(ret, location, splatarray, Qtrue);
10297 }
10298 return;
10299 }
10300 case PM_STATEMENTS_NODE: {
10301 // A list of statements.
10302 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
10303 const pm_node_list_t *body = &cast->body;
10304
10305 if (body->size > 0) {
10306 for (size_t index = 0; index < body->size - 1; index++) {
10307 PM_COMPILE_POPPED(body->nodes[index]);
10308 }
10309 PM_COMPILE(body->nodes[body->size - 1]);
10310 }
10311 else {
10312 PUSH_INSN(ret, location, putnil);
10313 }
10314 return;
10315 }
10316 case PM_STRING_NODE: {
10317 // "foo"
10318 // ^^^^^
10319 if (!popped) {
10320 const pm_string_node_t *cast = (const pm_string_node_t *) node;
10321 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
10322
10323 if (PM_NODE_FLAG_P(node, PM_STRING_FLAGS_FROZEN)) {
10324 PUSH_INSN1(ret, location, putobject, value);
10325 }
10326 else if (PM_NODE_FLAG_P(node, PM_STRING_FLAGS_MUTABLE)) {
10327 PUSH_INSN1(ret, location, putstring, value);
10328 }
10329 else {
10330 PUSH_INSN1(ret, location, putchilledstring, value);
10331 }
10332 }
10333 return;
10334 }
10335 case PM_SUPER_NODE:
10336 // super()
10337 // super(foo)
10338 // super(...)
10339 pm_compile_super_node(iseq, (const pm_super_node_t *) node, &location, ret, popped, scope_node);
10340 return;
10341 case PM_SYMBOL_NODE: {
10342 // :foo
10343 // ^^^^
10344 if (!popped) {
10345 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10346 PUSH_INSN1(ret, location, putobject, value);
10347 }
10348 return;
10349 }
10350 case PM_TRUE_NODE: {
10351 // true
10352 // ^^^^
10353 if (!popped) {
10354 PUSH_INSN1(ret, location, putobject, Qtrue);
10355 }
10356 return;
10357 }
10358 case PM_UNDEF_NODE: {
10359 // undef foo
10360 // ^^^^^^^^^
10361 const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
10362 const pm_node_list_t *names = &cast->names;
10363
10364 for (size_t index = 0; index < names->size; index++) {
10365 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
10366 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
10367
10368 PM_COMPILE_NOT_POPPED(names->nodes[index]);
10369 PUSH_SEND(ret, location, id_core_undef_method, INT2NUM(2));
10370
10371 if (index < names->size - 1) {
10372 PUSH_INSN(ret, location, pop);
10373 }
10374 }
10375
10376 if (popped) PUSH_INSN(ret, location, pop);
10377 return;
10378 }
10379 case PM_UNLESS_NODE: {
10380 // unless foo; bar end
10381 // ^^^^^^^^^^^^^^^^^^^
10382 //
10383 // bar unless foo
10384 // ^^^^^^^^^^^^^^
10385 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
10386 const pm_statements_node_t *statements = NULL;
10387 if (cast->else_clause != NULL) {
10388 statements = ((const pm_else_node_t *) cast->else_clause)->statements;
10389 }
10390
10391 pm_compile_conditional(iseq, &location, PM_UNLESS_NODE, (const pm_node_t *) cast, statements, (const pm_node_t *) cast->statements, cast->predicate, ret, popped, scope_node);
10392 return;
10393 }
10394 case PM_UNTIL_NODE: {
10395 // until foo; bar end
10396 // ^^^^^^^^^^^^^^^^^
10397 //
10398 // bar until foo
10399 // ^^^^^^^^^^^^^
10400 const pm_until_node_t *cast = (const pm_until_node_t *) node;
10401 pm_compile_loop(iseq, &location, cast->base.flags, PM_UNTIL_NODE, (const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10402 return;
10403 }
10404 case PM_WHILE_NODE: {
10405 // while foo; bar end
10406 // ^^^^^^^^^^^^^^^^^^
10407 //
10408 // bar while foo
10409 // ^^^^^^^^^^^^^
10410 const pm_while_node_t *cast = (const pm_while_node_t *) node;
10411 pm_compile_loop(iseq, &location, cast->base.flags, PM_WHILE_NODE, (const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10412 return;
10413 }
10414 case PM_X_STRING_NODE: {
10415 // `foo`
10416 // ^^^^^
10417 const pm_x_string_node_t *cast = (const pm_x_string_node_t *) node;
10418 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
10419
10420 PUSH_INSN(ret, location, putself);
10421 PUSH_INSN1(ret, location, putobject, value);
10422 PUSH_SEND_WITH_FLAG(ret, location, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
10423 if (popped) PUSH_INSN(ret, location, pop);
10424
10425 return;
10426 }
10427 case PM_YIELD_NODE:
10428 // yield
10429 // ^^^^^
10430 //
10431 // yield 1
10432 // ^^^^^^^
10433 pm_compile_yield_node(iseq, (const pm_yield_node_t *) node, &location, ret, popped, scope_node);
10434 return;
10435 default:
10436 rb_raise(rb_eNotImpError, "node type %s not implemented", pm_node_type_to_str(PM_NODE_TYPE(node)));
10437 return;
10438 }
10439}
10440
10441#undef PM_CONTAINER_P
10442
10444static inline bool
10445pm_iseq_pre_execution_p(rb_iseq_t *iseq)
10446{
10447 switch (ISEQ_BODY(iseq)->type) {
10448 case ISEQ_TYPE_TOP:
10449 case ISEQ_TYPE_EVAL:
10450 case ISEQ_TYPE_MAIN:
10451 return true;
10452 default:
10453 return false;
10454 }
10455}
10456
10464 VALUE
10465pm_iseq_compile_node(rb_iseq_t *iseq, pm_scope_node_t *node)
10466{
10467 DECL_ANCHOR(ret);
10468
10469 if (pm_iseq_pre_execution_p(iseq)) {
10470 // Because these ISEQs can have BEGIN{}, we're going to create two
10471 // anchors to compile them, a "pre" and a "body". We'll mark the "pre"
10472 // on the scope node so that when BEGIN{} is found, its contents will be
10473 // added to the "pre" anchor.
10474 DECL_ANCHOR(pre);
10475 node->pre_execution_anchor = pre;
10476
10477 // Now we'll compile the body as normal. We won't compile directly into
10478 // the "ret" anchor yet because we want to add the "pre" anchor to the
10479 // beginning of the "ret" anchor first.
10480 DECL_ANCHOR(body);
10481 pm_compile_node(iseq, (const pm_node_t *) node, body, false, node);
10482
10483 // Now we'll join both anchors together so that the content is in the
10484 // correct order.
10485 PUSH_SEQ(ret, pre);
10486 PUSH_SEQ(ret, body);
10487 }
10488 else {
10489 // In other circumstances, we can just compile the node directly into
10490 // the "ret" anchor.
10491 pm_compile_node(iseq, (const pm_node_t *) node, ret, false, node);
10492 }
10493
10494 CHECK(iseq_setup_insn(iseq, ret));
10495 return iseq_setup(iseq, ret);
10496}
10497
10502void
10503pm_parse_result_free(pm_parse_result_t *result)
10504{
10505 if (result->node.ast_node != NULL) {
10506 pm_node_destroy(&result->parser, result->node.ast_node);
10507 }
10508
10509 if (result->parsed) {
10510 xfree(result->node.constants);
10511 pm_scope_node_destroy(&result->node);
10512 }
10513
10514 pm_parser_free(&result->parser);
10515 pm_string_free(&result->input);
10516 pm_options_free(&result->options);
10517}
10518
10520 typedef struct {
10522 pm_diagnostic_t *error;
10523
10525 int32_t line;
10526
10528 uint32_t column_start;
10529
10531 uint32_t column_end;
10532} pm_parse_error_t;
10533
10535 typedef struct {
10537 const char *number_prefix;
10538
10540 const char *blank_prefix;
10541
10543 const char *divider;
10544
10546 size_t blank_prefix_length;
10547
10549 size_t divider_length;
10550} pm_parse_error_format_t;
10551
10552#define PM_COLOR_BOLD "\033[1m"
10553#define PM_COLOR_GRAY "\033[2m"
10554#define PM_COLOR_RED "\033[1;31m"
10555#define PM_COLOR_RESET "\033[m"
10556#define PM_ERROR_TRUNCATE 30
10557
10558static inline pm_parse_error_t *
10559pm_parse_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_list, const pm_newline_list_t *newline_list) {
10560 pm_parse_error_t *errors = xcalloc(error_list->size, sizeof(pm_parse_error_t));
10561 if (errors == NULL) return NULL;
10562
10563 int32_t start_line = parser->start_line;
10564 for (pm_diagnostic_t *error = (pm_diagnostic_t *) error_list->head; error != NULL; error = (pm_diagnostic_t *) error->node.next) {
10565 pm_line_column_t start = pm_newline_list_line_column(newline_list, error->location.start, start_line);
10566 pm_line_column_t end = pm_newline_list_line_column(newline_list, error->location.end, start_line);
10567
10568 // We're going to insert this error into the array in sorted order. We
10569 // do this by finding the first error that has a line number greater
10570 // than the current error and then inserting the current error before
10571 // that one.
10572 size_t index = 0;
10573 while (
10574 (index < error_list->size) &&
10575 (errors[index].error != NULL) &&
10576 (
10577 (errors[index].line < start.line) ||
10578 ((errors[index].line == start.line) && (errors[index].column_start < start.column))
10579 )
10580 ) index++;
10581
10582 // Now we're going to shift all of the errors after this one down one
10583 // index to make room for the new error.
10584 if (index + 1 < error_list->size) {
10585 memmove(&errors[index + 1], &errors[index], sizeof(pm_parse_error_t) * (error_list->size - index - 1));
10586 }
10587
10588 // Finally, we'll insert the error into the array.
10589 uint32_t column_end;
10590 if (start.line == end.line) {
10591 column_end = end.column;
10592 } else {
10593 column_end = (uint32_t) (newline_list->offsets[start.line - start_line + 1] - newline_list->offsets[start.line - start_line] - 1);
10594 }
10595
10596 // Ensure we have at least one column of error.
10597 if (start.column == column_end) column_end++;
10598
10599 errors[index] = (pm_parse_error_t) {
10600 .error = error,
10601 .line = start.line,
10602 .column_start = start.column,
10603 .column_end = column_end
10604 };
10605 }
10606
10607 return errors;
10608}
10609
10610/* Append a literal string to the buffer. */
10611#define pm_buffer_append_literal(buffer, str) pm_buffer_append_string(buffer, str, rb_strlen_lit(str))
10612
10613static inline void
10614pm_parse_errors_format_line(const pm_parser_t *parser, const pm_newline_list_t *newline_list, const char *number_prefix, int32_t line, uint32_t column_start, uint32_t column_end, pm_buffer_t *buffer) {
10615 int32_t line_delta = line - parser->start_line;
10616 assert(line_delta >= 0);
10617
10618 size_t index = (size_t) line_delta;
10619 assert(index < newline_list->size);
10620
10621 const uint8_t *start = &parser->start[newline_list->offsets[index]];
10622 const uint8_t *end;
10623
10624 if (index >= newline_list->size - 1) {
10625 end = parser->end;
10626 } else {
10627 end = &parser->start[newline_list->offsets[index + 1]];
10628 }
10629
10630 pm_buffer_append_format(buffer, number_prefix, line);
10631
10632 // Here we determine if we should truncate the end of the line.
10633 bool truncate_end = false;
10634 if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
10635 end = start + column_end + PM_ERROR_TRUNCATE;
10636 truncate_end = true;
10637 }
10638
10639 // Here we determine if we should truncate the start of the line.
10640 if (column_start >= PM_ERROR_TRUNCATE) {
10641 pm_buffer_append_string(buffer, "... ", 4);
10642 start += column_start;
10643 }
10644
10645 pm_buffer_append_string(buffer, (const char *) start, (size_t) (end - start));
10646
10647 if (truncate_end) {
10648 pm_buffer_append_string(buffer, " ...\n", 5);
10649 } else if (end == parser->end && end[-1] != '\n') {
10650 pm_buffer_append_string(buffer, "\n", 1);
10651 }
10652}
10653
10657static void
10658pm_parse_errors_format(const pm_parser_t *parser, const pm_list_t *error_list, pm_buffer_t *buffer, int highlight, bool inline_messages) {
10659 assert(error_list->size != 0);
10660
10661 // First, we're going to sort all of the errors by line number using an
10662 // insertion sort into a newly allocated array.
10663 const int32_t start_line = parser->start_line;
10664 const pm_newline_list_t *newline_list = &parser->newline_list;
10665
10666 pm_parse_error_t *errors = pm_parse_errors_format_sort(parser, error_list, newline_list);
10667 if (errors == NULL) return;
10668
10669 // Now we're going to determine how we're going to format line numbers and
10670 // blank lines based on the maximum number of digits in the line numbers
10671 // that are going to be displaid.
10672 pm_parse_error_format_t error_format;
10673 int32_t first_line_number = errors[0].line;
10674 int32_t last_line_number = errors[error_list->size - 1].line;
10675
10676 // If we have a maximum line number that is negative, then we're going to
10677 // use the absolute value for comparison but multiple by 10 to additionally
10678 // have a column for the negative sign.
10679 if (first_line_number < 0) first_line_number = (-first_line_number) * 10;
10680 if (last_line_number < 0) last_line_number = (-last_line_number) * 10;
10681 int32_t max_line_number = first_line_number > last_line_number ? first_line_number : last_line_number;
10682
10683 if (max_line_number < 10) {
10684 if (highlight > 0) {
10685 error_format = (pm_parse_error_format_t) {
10686 .number_prefix = PM_COLOR_GRAY "%1" PRIi32 " | " PM_COLOR_RESET,
10687 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10688 .divider = PM_COLOR_GRAY " ~~~~~" PM_COLOR_RESET "\n"
10689 };
10690 } else {
10691 error_format = (pm_parse_error_format_t) {
10692 .number_prefix = "%1" PRIi32 " | ",
10693 .blank_prefix = " | ",
10694 .divider = " ~~~~~\n"
10695 };
10696 }
10697 } else if (max_line_number < 100) {
10698 if (highlight > 0) {
10699 error_format = (pm_parse_error_format_t) {
10700 .number_prefix = PM_COLOR_GRAY "%2" PRIi32 " | " PM_COLOR_RESET,
10701 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10702 .divider = PM_COLOR_GRAY " ~~~~~~" PM_COLOR_RESET "\n"
10703 };
10704 } else {
10705 error_format = (pm_parse_error_format_t) {
10706 .number_prefix = "%2" PRIi32 " | ",
10707 .blank_prefix = " | ",
10708 .divider = " ~~~~~~\n"
10709 };
10710 }
10711 } else if (max_line_number < 1000) {
10712 if (highlight > 0) {
10713 error_format = (pm_parse_error_format_t) {
10714 .number_prefix = PM_COLOR_GRAY "%3" PRIi32 " | " PM_COLOR_RESET,
10715 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10716 .divider = PM_COLOR_GRAY " ~~~~~~~" PM_COLOR_RESET "\n"
10717 };
10718 } else {
10719 error_format = (pm_parse_error_format_t) {
10720 .number_prefix = "%3" PRIi32 " | ",
10721 .blank_prefix = " | ",
10722 .divider = " ~~~~~~~\n"
10723 };
10724 }
10725 } else if (max_line_number < 10000) {
10726 if (highlight > 0) {
10727 error_format = (pm_parse_error_format_t) {
10728 .number_prefix = PM_COLOR_GRAY "%4" PRIi32 " | " PM_COLOR_RESET,
10729 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10730 .divider = PM_COLOR_GRAY " ~~~~~~~~" PM_COLOR_RESET "\n"
10731 };
10732 } else {
10733 error_format = (pm_parse_error_format_t) {
10734 .number_prefix = "%4" PRIi32 " | ",
10735 .blank_prefix = " | ",
10736 .divider = " ~~~~~~~~\n"
10737 };
10738 }
10739 } else {
10740 if (highlight > 0) {
10741 error_format = (pm_parse_error_format_t) {
10742 .number_prefix = PM_COLOR_GRAY "%5" PRIi32 " | " PM_COLOR_RESET,
10743 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10744 .divider = PM_COLOR_GRAY " ~~~~~~~~" PM_COLOR_RESET "\n"
10745 };
10746 } else {
10747 error_format = (pm_parse_error_format_t) {
10748 .number_prefix = "%5" PRIi32 " | ",
10749 .blank_prefix = " | ",
10750 .divider = " ~~~~~~~~\n"
10751 };
10752 }
10753 }
10754
10755 error_format.blank_prefix_length = strlen(error_format.blank_prefix);
10756 error_format.divider_length = strlen(error_format.divider);
10757
10758 // Now we're going to iterate through every error in our error list and
10759 // display it. While we're iterating, we will display some padding lines of
10760 // the source before the error to give some context. We'll be careful not to
10761 // display the same line twice in case the errors are close enough in the
10762 // source.
10763 int32_t last_line = parser->start_line - 1;
10764 uint32_t last_column_start = 0;
10765 const pm_encoding_t *encoding = parser->encoding;
10766
10767 for (size_t index = 0; index < error_list->size; index++) {
10768 pm_parse_error_t *error = &errors[index];
10769
10770 // Here we determine how many lines of padding of the source to display,
10771 // based on the difference from the last line that was displaid.
10772 if (error->line - last_line > 1) {
10773 if (error->line - last_line > 2) {
10774 if ((index != 0) && (error->line - last_line > 3)) {
10775 pm_buffer_append_string(buffer, error_format.divider, error_format.divider_length);
10776 }
10777
10778 pm_buffer_append_string(buffer, " ", 2);
10779 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 2, 0, 0, buffer);
10780 }
10781
10782 pm_buffer_append_string(buffer, " ", 2);
10783 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 1, 0, 0, buffer);
10784 }
10785
10786 // If this is the first error or we're on a new line, then we'll display
10787 // the line that has the error in it.
10788 if ((index == 0) || (error->line != last_line)) {
10789 if (highlight > 1) {
10790 pm_buffer_append_literal(buffer, PM_COLOR_RED "> " PM_COLOR_RESET);
10791 } else if (highlight > 0) {
10792 pm_buffer_append_literal(buffer, PM_COLOR_BOLD "> " PM_COLOR_RESET);
10793 } else {
10794 pm_buffer_append_literal(buffer, "> ");
10795 }
10796
10797 last_column_start = error->column_start;
10798
10799 // Find the maximum column end of all the errors on this line.
10800 uint32_t column_end = error->column_end;
10801 for (size_t next_index = index + 1; next_index < error_list->size; next_index++) {
10802 if (errors[next_index].line != error->line) break;
10803 if (errors[next_index].column_end > column_end) column_end = errors[next_index].column_end;
10804 }
10805
10806 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line, error->column_start, column_end, buffer);
10807 }
10808
10809 const uint8_t *start = &parser->start[newline_list->offsets[error->line - start_line]];
10810 if (start == parser->end) pm_buffer_append_byte(buffer, '\n');
10811
10812 // Now we'll display the actual error message. We'll do this by first
10813 // putting the prefix to the line, then a bunch of blank spaces
10814 // depending on the column, then as many carets as we need to display
10815 // the width of the error, then the error message itself.
10816 //
10817 // Note that this doesn't take into account the width of the actual
10818 // character when displaid in the terminal. For some east-asian
10819 // languages or emoji, this means it can be thrown off pretty badly. We
10820 // will need to solve this eventually.
10821 pm_buffer_append_string(buffer, " ", 2);
10822 pm_buffer_append_string(buffer, error_format.blank_prefix, error_format.blank_prefix_length);
10823
10824 size_t column = 0;
10825 if (last_column_start >= PM_ERROR_TRUNCATE) {
10826 pm_buffer_append_string(buffer, " ", 4);
10827 column = last_column_start;
10828 }
10829
10830 while (column < error->column_start) {
10831 pm_buffer_append_byte(buffer, ' ');
10832
10833 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10834 column += (char_width == 0 ? 1 : char_width);
10835 }
10836
10837 if (highlight > 1) pm_buffer_append_literal(buffer, PM_COLOR_RED);
10838 else if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_BOLD);
10839 pm_buffer_append_byte(buffer, '^');
10840
10841 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10842 column += (char_width == 0 ? 1 : char_width);
10843
10844 while (column < error->column_end) {
10845 pm_buffer_append_byte(buffer, '~');
10846
10847 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10848 column += (char_width == 0 ? 1 : char_width);
10849 }
10850
10851 if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_RESET);
10852
10853 if (inline_messages) {
10854 pm_buffer_append_byte(buffer, ' ');
10855 assert(error->error != NULL);
10856
10857 const char *message = error->error->message;
10858 pm_buffer_append_string(buffer, message, strlen(message));
10859 }
10860
10861 pm_buffer_append_byte(buffer, '\n');
10862
10863 // Here we determine how many lines of padding to display after the
10864 // error, depending on where the next error is in source.
10865 last_line = error->line;
10866 int32_t next_line;
10867
10868 if (index == error_list->size - 1) {
10869 next_line = (((int32_t) newline_list->size) + parser->start_line);
10870
10871 // If the file ends with a newline, subtract one from our "next_line"
10872 // so that we don't output an extra line at the end of the file
10873 if ((parser->start + newline_list->offsets[newline_list->size - 1]) == parser->end) {
10874 next_line--;
10875 }
10876 }
10877 else {
10878 next_line = errors[index + 1].line;
10879 }
10880
10881 if (next_line - last_line > 1) {
10882 pm_buffer_append_string(buffer, " ", 2);
10883 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
10884 }
10885
10886 if (next_line - last_line > 1) {
10887 pm_buffer_append_string(buffer, " ", 2);
10888 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
10889 }
10890 }
10891
10892 // Finally, we'll free the array of errors that we allocated.
10893 xfree(errors);
10894}
10895
10896#undef PM_ERROR_TRUNCATE
10897#undef PM_COLOR_GRAY
10898#undef PM_COLOR_RED
10899#undef PM_COLOR_RESET
10900
10907static bool
10908pm_parse_process_error_utf8_p(const pm_parser_t *parser, const pm_location_t *location)
10909{
10910 const size_t start_line = pm_newline_list_line_column(&parser->newline_list, location->start, 1).line;
10911 const size_t end_line = pm_newline_list_line_column(&parser->newline_list, location->end, 1).line;
10912
10913 const uint8_t *start = parser->start + parser->newline_list.offsets[start_line - 1];
10914 const uint8_t *end = ((end_line == parser->newline_list.size) ? parser->end : (parser->start + parser->newline_list.offsets[end_line]));
10915 size_t width;
10916
10917 while (start < end) {
10918 if ((width = pm_encoding_utf_8_char_width(start, end - start)) == 0) return false;
10919 start += width;
10920 }
10921
10922 return true;
10923}
10924
10929static VALUE
10930pm_parse_process_error(const pm_parse_result_t *result)
10931{
10932 const pm_parser_t *parser = &result->parser;
10933 const pm_diagnostic_t *head = (const pm_diagnostic_t *) parser->error_list.head;
10934 bool valid_utf8 = true;
10935
10936 pm_buffer_t buffer = { 0 };
10937 const pm_string_t *filepath = &parser->filepath;
10938
10939 int highlight = rb_stderr_tty_p();
10940 if (highlight) {
10941 const char *no_color = getenv("NO_COLOR");
10942 highlight = (no_color == NULL || no_color[0] == '\0') ? 2 : 1;
10943 }
10944
10945 for (const pm_diagnostic_t *error = head; error != NULL; error = (const pm_diagnostic_t *) error->node.next) {
10946 switch (error->level) {
10947 case PM_ERROR_LEVEL_SYNTAX:
10948 // It is implicitly assumed that the error messages will be
10949 // encodeable as UTF-8. Because of this, we can't include source
10950 // examples that contain invalid byte sequences. So if any source
10951 // examples include invalid UTF-8 byte sequences, we will skip
10952 // showing source examples entirely.
10953 if (valid_utf8 && !pm_parse_process_error_utf8_p(parser, &error->location)) {
10954 valid_utf8 = false;
10955 }
10956 break;
10957 case PM_ERROR_LEVEL_ARGUMENT: {
10958 // Any errors with the level PM_ERROR_LEVEL_ARGUMENT take over as
10959 // the only argument that gets raised. This is to allow priority
10960 // messages that should be handled before anything else.
10961 int32_t line_number = (int32_t) pm_location_line_number(parser, &error->location);
10962
10963 pm_buffer_append_format(
10964 &buffer,
10965 "%.*s:%" PRIi32 ": %s",
10966 (int) pm_string_length(filepath),
10967 pm_string_source(filepath),
10968 line_number,
10969 error->message
10970 );
10971
10972 if (pm_parse_process_error_utf8_p(parser, &error->location)) {
10973 pm_buffer_append_byte(&buffer, '\n');
10974
10975 pm_list_node_t *list_node = (pm_list_node_t *) error;
10976 pm_list_t error_list = { .size = 1, .head = list_node, .tail = list_node };
10977
10978 pm_parse_errors_format(parser, &error_list, &buffer, highlight, false);
10979 }
10980
10981 VALUE value = rb_exc_new(rb_eArgError, pm_buffer_value(&buffer), pm_buffer_length(&buffer));
10982 pm_buffer_free(&buffer);
10983
10984 return value;
10985 }
10986 case PM_ERROR_LEVEL_LOAD: {
10987 // Load errors are much simpler, because they don't include any of
10988 // the source in them. We create the error directly from the
10989 // message.
10990 VALUE message = rb_enc_str_new_cstr(error->message, rb_locale_encoding());
10991 VALUE value = rb_exc_new3(rb_eLoadError, message);
10992 rb_ivar_set(value, rb_intern_const("@path"), Qnil);
10993 return value;
10994 }
10995 }
10996 }
10997
10998 pm_buffer_append_format(
10999 &buffer,
11000 "%.*s:%" PRIi32 ": syntax error%s found\n",
11001 (int) pm_string_length(filepath),
11002 pm_string_source(filepath),
11003 (int32_t) pm_location_line_number(parser, &head->location),
11004 (parser->error_list.size > 1) ? "s" : ""
11005 );
11006
11007 if (valid_utf8) {
11008 pm_parse_errors_format(parser, &parser->error_list, &buffer, highlight, true);
11009 }
11010 else {
11011 for (const pm_diagnostic_t *error = head; error != NULL; error = (const pm_diagnostic_t *) error->node.next) {
11012 if (error != head) pm_buffer_append_byte(&buffer, '\n');
11013 pm_buffer_append_format(&buffer, "%.*s:%" PRIi32 ": %s", (int) pm_string_length(filepath), pm_string_source(filepath), (int32_t) pm_location_line_number(parser, &error->location), error->message);
11014 }
11015 }
11016
11017 VALUE message = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), result->node.encoding);
11018 VALUE error = rb_exc_new_str(rb_eSyntaxError, message);
11019
11020 rb_encoding *filepath_encoding = result->node.filepath_encoding != NULL ? result->node.filepath_encoding : rb_utf8_encoding();
11021 VALUE path = rb_enc_str_new((const char *) pm_string_source(filepath), pm_string_length(filepath), filepath_encoding);
11022
11023 rb_ivar_set(error, rb_intern_const("@path"), path);
11024 pm_buffer_free(&buffer);
11025
11026 return error;
11027}
11028
11034static VALUE
11035pm_parse_process(pm_parse_result_t *result, pm_node_t *node, VALUE *script_lines)
11036{
11037 pm_parser_t *parser = &result->parser;
11038
11039 // First, set up the scope node so that the AST node is attached and can be
11040 // freed regardless of whether or we return an error.
11041 pm_scope_node_t *scope_node = &result->node;
11042 rb_encoding *filepath_encoding = scope_node->filepath_encoding;
11043 int coverage_enabled = scope_node->coverage_enabled;
11044
11045 pm_scope_node_init(node, scope_node, NULL);
11046 scope_node->filepath_encoding = filepath_encoding;
11047
11048 scope_node->encoding = rb_enc_find(parser->encoding->name);
11049 if (!scope_node->encoding) rb_bug("Encoding not found %s!", parser->encoding->name);
11050
11051 scope_node->coverage_enabled = coverage_enabled;
11052
11053 // If RubyVM.keep_script_lines is set to true, then we need to create that
11054 // array of script lines here.
11055 if (script_lines != NULL) {
11056 *script_lines = rb_ary_new_capa(parser->newline_list.size);
11057
11058 for (size_t index = 0; index < parser->newline_list.size; index++) {
11059 size_t offset = parser->newline_list.offsets[index];
11060 size_t length = index == parser->newline_list.size - 1 ? ((size_t) (parser->end - (parser->start + offset))) : (parser->newline_list.offsets[index + 1] - offset);
11061 rb_ary_push(*script_lines, rb_enc_str_new((const char *) parser->start + offset, length, scope_node->encoding));
11062 }
11063
11064 scope_node->script_lines = script_lines;
11065 }
11066
11067 // Emit all of the various warnings from the parse.
11068 const pm_diagnostic_t *warning;
11069 const char *warning_filepath = (const char *) pm_string_source(&parser->filepath);
11070
11071 for (warning = (const pm_diagnostic_t *) parser->warning_list.head; warning != NULL; warning = (const pm_diagnostic_t *) warning->node.next) {
11072 int line = pm_location_line_number(parser, &warning->location);
11073
11074 if (warning->level == PM_WARNING_LEVEL_VERBOSE) {
11075 rb_enc_compile_warning(scope_node->encoding, warning_filepath, line, "%s", warning->message);
11076 }
11077 else {
11078 rb_enc_compile_warn(scope_node->encoding, warning_filepath, line, "%s", warning->message);
11079 }
11080 }
11081
11082 // If there are errors, raise an appropriate error and free the result.
11083 if (parser->error_list.size > 0) {
11084 VALUE error = pm_parse_process_error(result);
11085
11086 // TODO: We need to set the backtrace.
11087 // rb_funcallv(error, rb_intern("set_backtrace"), 1, &path);
11088 return error;
11089 }
11090
11091 // Now set up the constant pool and intern all of the various constants into
11092 // their corresponding IDs.
11093 scope_node->parser = parser;
11094 scope_node->constants = xcalloc(parser->constant_pool.size, sizeof(ID));
11095
11096 for (uint32_t index = 0; index < parser->constant_pool.size; index++) {
11097 pm_constant_t *constant = &parser->constant_pool.constants[index];
11098 scope_node->constants[index] = rb_intern3((const char *) constant->start, constant->length, scope_node->encoding);
11099 }
11100
11101 scope_node->index_lookup_table = st_init_numtable();
11102 pm_constant_id_list_t *locals = &scope_node->locals;
11103 for (size_t index = 0; index < locals->size; index++) {
11104 st_insert(scope_node->index_lookup_table, locals->ids[index], index);
11105 }
11106
11107 // If we got here, this is a success and we can return Qnil to indicate that
11108 // no error should be raised.
11109 result->parsed = true;
11110 return Qnil;
11111}
11112
11117static void
11118pm_options_frozen_string_literal_init(pm_options_t *options)
11119{
11120 int frozen_string_literal = rb_iseq_opt_frozen_string_literal();
11121
11122 switch (frozen_string_literal) {
11123 case ISEQ_FROZEN_STRING_LITERAL_UNSET:
11124 break;
11125 case ISEQ_FROZEN_STRING_LITERAL_DISABLED:
11126 pm_options_frozen_string_literal_set(options, false);
11127 break;
11128 case ISEQ_FROZEN_STRING_LITERAL_ENABLED:
11129 pm_options_frozen_string_literal_set(options, true);
11130 break;
11131 default:
11132 rb_bug("pm_options_frozen_string_literal_init: invalid frozen_string_literal=%d", frozen_string_literal);
11133 break;
11134 }
11135}
11136
11141static inline VALUE
11142pm_parse_file_script_lines(const pm_scope_node_t *scope_node, const pm_parser_t *parser)
11143{
11144 const pm_newline_list_t *newline_list = &parser->newline_list;
11145 const char *start = (const char *) parser->start;
11146 const char *end = (const char *) parser->end;
11147
11148 // If we end exactly on a newline, then there's no need to push on a final
11149 // segment. If we don't, then we need to push on the last offset up to the
11150 // end of the string.
11151 size_t last_offset = newline_list->offsets[newline_list->size - 1];
11152 bool last_push = start + last_offset != end;
11153
11154 // Create the ruby strings that represent the lines of the source.
11155 VALUE lines = rb_ary_new_capa(newline_list->size - (last_push ? 0 : 1));
11156
11157 for (size_t index = 0; index < newline_list->size - 1; index++) {
11158 size_t offset = newline_list->offsets[index];
11159 size_t length = newline_list->offsets[index + 1] - offset;
11160
11161 rb_ary_push(lines, rb_enc_str_new(start + offset, length, scope_node->encoding));
11162 }
11163
11164 // Push on the last line if we need to.
11165 if (last_push) {
11166 rb_ary_push(lines, rb_enc_str_new(start + last_offset, end - (start + last_offset), scope_node->encoding));
11167 }
11168
11169 return lines;
11170}
11171
11172// This is essentially pm_string_mapped_init(), preferring to memory map the
11173// file, with additional handling for files that require blocking to properly
11174// read (e.g. pipes).
11175static pm_string_init_result_t
11176pm_read_file(pm_string_t *string, const char *filepath)
11177{
11178#ifdef _WIN32
11179 // Open the file for reading.
11180 int length = MultiByteToWideChar(CP_UTF8, 0, filepath, -1, NULL, 0);
11181 if (length == 0) return PM_STRING_INIT_ERROR_GENERIC;
11182
11183 WCHAR *wfilepath = xmalloc(sizeof(WCHAR) * ((size_t) length));
11184 if ((wfilepath == NULL) || (MultiByteToWideChar(CP_UTF8, 0, filepath, -1, wfilepath, length) == 0)) {
11185 xfree(wfilepath);
11186 return PM_STRING_INIT_ERROR_GENERIC;
11187 }
11188
11189 HANDLE file = CreateFileW(wfilepath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
11190 if (file == INVALID_HANDLE_VALUE) {
11191 pm_string_init_result_t result = PM_STRING_INIT_ERROR_GENERIC;
11192
11193 if (GetLastError() == ERROR_ACCESS_DENIED) {
11194 DWORD attributes = GetFileAttributesW(wfilepath);
11195 if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
11196 result = PM_STRING_INIT_ERROR_DIRECTORY;
11197 }
11198 }
11199
11200 xfree(wfilepath);
11201 return result;
11202 }
11203
11204 // Get the file size.
11205 DWORD file_size = GetFileSize(file, NULL);
11206 if (file_size == INVALID_FILE_SIZE) {
11207 CloseHandle(file);
11208 xfree(wfilepath);
11209 return PM_STRING_INIT_ERROR_GENERIC;
11210 }
11211
11212 // If the file is empty, then we don't need to do anything else, we'll set
11213 // the source to a constant empty string and return.
11214 if (file_size == 0) {
11215 CloseHandle(file);
11216 xfree(wfilepath);
11217 const uint8_t source[] = "";
11218 *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11219 return PM_STRING_INIT_SUCCESS;
11220 }
11221
11222 // Create a mapping of the file.
11223 HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
11224 if (mapping == NULL) {
11225 CloseHandle(file);
11226 xfree(wfilepath);
11227 return PM_STRING_INIT_ERROR_GENERIC;
11228 }
11229
11230 // Map the file into memory.
11231 uint8_t *source = (uint8_t *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
11232 CloseHandle(mapping);
11233 CloseHandle(file);
11234 xfree(wfilepath);
11235
11236 if (source == NULL) {
11237 return PM_STRING_INIT_ERROR_GENERIC;
11238 }
11239
11240 *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = (size_t) file_size };
11241 return PM_STRING_INIT_SUCCESS;
11242#elif defined(_POSIX_MAPPED_FILES)
11243 // Open the file for reading
11244 const int open_mode = O_RDONLY | O_NONBLOCK;
11245 int fd = open(filepath, open_mode);
11246 if (fd == -1) {
11247 return PM_STRING_INIT_ERROR_GENERIC;
11248 }
11249
11250 // Stat the file to get the file size
11251 struct stat sb;
11252 if (fstat(fd, &sb) == -1) {
11253 close(fd);
11254 return PM_STRING_INIT_ERROR_GENERIC;
11255 }
11256
11257 // Ensure it is a file and not a directory
11258 if (S_ISDIR(sb.st_mode)) {
11259 close(fd);
11260 return PM_STRING_INIT_ERROR_DIRECTORY;
11261 }
11262
11263 // We need to wait for data first before reading from pipes and character
11264 // devices. To not block the entire VM, we need to release the GVL while
11265 // reading. Use IO#read to do this and let the GC handle closing the FD.
11266 if (S_ISFIFO(sb.st_mode) || S_ISCHR(sb.st_mode)) {
11267 VALUE io = rb_io_fdopen((int) fd, open_mode, filepath);
11268 rb_io_wait(io, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
11269 VALUE contents = rb_funcall(io, rb_intern("read"), 0);
11270
11271 if (!RB_TYPE_P(contents, T_STRING)) {
11272 return PM_STRING_INIT_ERROR_GENERIC;
11273 }
11274
11275 long len = RSTRING_LEN(contents);
11276 if (len < 0) {
11277 return PM_STRING_INIT_ERROR_GENERIC;
11278 }
11279
11280 size_t length = (size_t) len;
11281 uint8_t *source = malloc(length);
11282 memcpy(source, RSTRING_PTR(contents), length);
11283 *string = (pm_string_t) { .type = PM_STRING_OWNED, .source = source, .length = length };
11284
11285 return PM_STRING_INIT_SUCCESS;
11286 }
11287
11288 // mmap the file descriptor to virtually get the contents
11289 size_t size = (size_t) sb.st_size;
11290 uint8_t *source = NULL;
11291
11292 if (size == 0) {
11293 close(fd);
11294 const uint8_t source[] = "";
11295 *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11296 return PM_STRING_INIT_SUCCESS;
11297 }
11298
11299 source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
11300 if (source == MAP_FAILED) {
11301 close(fd);
11302 return PM_STRING_INIT_ERROR_GENERIC;
11303 }
11304
11305 close(fd);
11306 *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = size };
11307 return PM_STRING_INIT_SUCCESS;
11308#else
11309 return pm_string_file_init(string, filepath);
11310#endif
11311}
11312
11317 VALUE
11318pm_load_file(pm_parse_result_t *result, VALUE filepath, bool load_error)
11319{
11320 pm_string_init_result_t init_result = pm_read_file(&result->input, RSTRING_PTR(filepath));
11321
11322 if (init_result == PM_STRING_INIT_SUCCESS) {
11323 pm_options_frozen_string_literal_init(&result->options);
11324 return Qnil;
11325 }
11326
11327 int err;
11328 if (init_result == PM_STRING_INIT_ERROR_DIRECTORY) {
11329 err = EISDIR;
11330 } else {
11331#ifdef _WIN32
11332 err = rb_w32_map_errno(GetLastError());
11333#else
11334 err = errno;
11335#endif
11336 }
11337
11338 VALUE error;
11339 if (load_error) {
11340 VALUE message = rb_str_buf_new_cstr(strerror(err));
11341 rb_str_cat2(message, " -- ");
11342 rb_str_append(message, filepath);
11343
11344 error = rb_exc_new3(rb_eLoadError, message);
11345 rb_ivar_set(error, rb_intern_const("@path"), filepath);
11346 } else {
11347 error = rb_syserr_new(err, RSTRING_PTR(filepath));
11348 RB_GC_GUARD(filepath);
11349 }
11350
11351 return error;
11352}
11353
11360 VALUE
11361pm_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
11362{
11363 result->node.filepath_encoding = rb_enc_get(filepath);
11364 pm_options_filepath_set(&result->options, RSTRING_PTR(filepath));
11365 RB_GC_GUARD(filepath);
11366
11367 pm_options_version_for_current_ruby_set(&result->options);
11368
11369 pm_parser_init(&result->parser, pm_string_source(&result->input), pm_string_length(&result->input), &result->options);
11370 pm_node_t *node = pm_parse(&result->parser);
11371
11372 VALUE error = pm_parse_process(result, node, script_lines);
11373
11374 // If we're parsing a filepath, then we need to potentially support the
11375 // SCRIPT_LINES__ constant, which can be a hash that has an array of lines
11376 // of every read file.
11377 ID id_script_lines = rb_intern("SCRIPT_LINES__");
11378
11379 if (rb_const_defined_at(rb_cObject, id_script_lines)) {
11380 VALUE constant_script_lines = rb_const_get_at(rb_cObject, id_script_lines);
11381
11382 if (RB_TYPE_P(constant_script_lines, T_HASH)) {
11383 rb_hash_aset(constant_script_lines, filepath, pm_parse_file_script_lines(&result->node, &result->parser));
11384 }
11385 }
11386
11387 return error;
11388}
11389
11394 VALUE
11395pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
11396{
11397 VALUE error = pm_load_file(result, filepath, false);
11398 if (NIL_P(error)) {
11399 error = pm_parse_file(result, filepath, script_lines);
11400 }
11401
11402 return error;
11403}
11404
11411 VALUE
11412pm_parse_string(pm_parse_result_t *result, VALUE source, VALUE filepath, VALUE *script_lines)
11413{
11414 rb_encoding *encoding = rb_enc_get(source);
11415 if (!rb_enc_asciicompat(encoding)) {
11416 return rb_exc_new_cstr(rb_eArgError, "invalid source encoding");
11417 }
11418
11419 pm_options_frozen_string_literal_init(&result->options);
11420 pm_string_constant_init(&result->input, RSTRING_PTR(source), RSTRING_LEN(source));
11421 pm_options_encoding_set(&result->options, rb_enc_name(encoding));
11422
11423 result->node.filepath_encoding = rb_enc_get(filepath);
11424 pm_options_filepath_set(&result->options, RSTRING_PTR(filepath));
11425 RB_GC_GUARD(filepath);
11426
11427 pm_options_version_for_current_ruby_set(&result->options);
11428
11429 pm_parser_init(&result->parser, pm_string_source(&result->input), pm_string_length(&result->input), &result->options);
11430 pm_node_t *node = pm_parse(&result->parser);
11431
11432 return pm_parse_process(result, node, script_lines);
11433}
11434
11435 struct rb_stdin_wrapper {
11436 VALUE rb_stdin;
11437 int eof_seen;
11438};
11439
11440static int
11441pm_parse_stdin_eof(void *stream)
11442{
11443 struct rb_stdin_wrapper * wrapped_stdin = (struct rb_stdin_wrapper *)stream;
11444 return wrapped_stdin->eof_seen;
11445}
11446
11450static char *
11451pm_parse_stdin_fgets(char *string, int size, void *stream)
11452{
11453 RUBY_ASSERT(size > 0);
11454
11455 struct rb_stdin_wrapper * wrapped_stdin = (struct rb_stdin_wrapper *)stream;
11456
11457 VALUE line = rb_funcall(wrapped_stdin->rb_stdin, rb_intern("gets"), 1, INT2FIX(size - 1));
11458 if (NIL_P(line)) {
11459 return NULL;
11460 }
11461
11462 const char *cstr = RSTRING_PTR(line);
11463 long length = RSTRING_LEN(line);
11464
11465 memcpy(string, cstr, length);
11466 string[length] = '\0';
11467
11468 // We're reading strings from stdin via gets. We'll assume that if the
11469 // string is smaller than the requested length, and doesn't end with a
11470 // newline, that we hit EOF.
11471 if (length < (size - 1) && string[length - 1] != '\n') {
11472 wrapped_stdin->eof_seen = 1;
11473 }
11474
11475 return string;
11476}
11477
11478// We need access to this function when we're done parsing stdin.
11479void rb_reset_argf_lineno(long n);
11480
11486 VALUE
11487pm_parse_stdin(pm_parse_result_t *result)
11488{
11489 pm_options_frozen_string_literal_init(&result->options);
11490
11491 struct rb_stdin_wrapper wrapped_stdin = {
11492 rb_stdin,
11493 0
11494 };
11495
11496 pm_buffer_t buffer;
11497 pm_node_t *node = pm_parse_stream(&result->parser, &buffer, (void *) &wrapped_stdin, pm_parse_stdin_fgets, pm_parse_stdin_eof, &result->options);
11498
11499 // Copy the allocated buffer contents into the input string so that it gets
11500 // freed. At this point we've handed over ownership, so we don't need to
11501 // free the buffer itself.
11502 pm_string_owned_init(&result->input, (uint8_t *) pm_buffer_value(&buffer), pm_buffer_length(&buffer));
11503
11504 // When we're done parsing, we reset $. because we don't want the fact that
11505 // we went through an IO object to be visible to the user.
11506 rb_reset_argf_lineno(0);
11507
11508 return pm_parse_process(result, node, NULL);
11509}
11510
11511#define PM_VERSION_FOR_RELEASE(major, minor) PM_VERSION_FOR_RELEASE_IMPL(major, minor)
11512#define PM_VERSION_FOR_RELEASE_IMPL(major, minor) PM_OPTIONS_VERSION_CRUBY_##major##_##minor
11513
11514void pm_options_version_for_current_ruby_set(pm_options_t *options) {
11515 options->version = PM_VERSION_FOR_RELEASE(RUBY_VERSION_MAJOR, RUBY_VERSION_MINOR);
11516}
11517
11518#undef NEW_ISEQ
11519#define NEW_ISEQ OLD_ISEQ
11520
11521#undef NEW_CHILD_ISEQ
11522#define NEW_CHILD_ISEQ OLD_CHILD_ISEQ
RUBY_ASSERT
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
PM_WARNING_LEVEL_VERBOSE
@ PM_WARNING_LEVEL_VERBOSE
For warnings which should be emitted if $VERBOSE == true.
Definition diagnostic.h:412
PM_ERROR_LEVEL_ARGUMENT
@ PM_ERROR_LEVEL_ARGUMENT
For errors that should raise an argument error.
Definition diagnostic.h:398
PM_ERROR_LEVEL_LOAD
@ PM_ERROR_LEVEL_LOAD
For errors that should raise a load error.
Definition diagnostic.h:401
PM_ERROR_LEVEL_SYNTAX
@ PM_ERROR_LEVEL_SYNTAX
For errors that should raise a syntax error.
Definition diagnostic.h:395
RUBY_EVENT_END
#define RUBY_EVENT_END
Encountered an end of a class clause.
Definition event.h:40
RUBY_EVENT_B_RETURN
#define RUBY_EVENT_B_RETURN
Encountered a next statement.
Definition event.h:56
RUBY_EVENT_CLASS
#define RUBY_EVENT_CLASS
Encountered a new class.
Definition event.h:39
RUBY_EVENT_LINE
#define RUBY_EVENT_LINE
Encountered a new line.
Definition event.h:38
RUBY_EVENT_RETURN
#define RUBY_EVENT_RETURN
Encountered a return statement.
Definition event.h:42
RUBY_EVENT_B_CALL
#define RUBY_EVENT_B_CALL
Encountered an yield statement.
Definition event.h:55
RUBY_EVENT_CALL
#define RUBY_EVENT_CALL
A method, written in Ruby, is called.
Definition event.h:41
RUBY_EVENT_RESCUE
#define RUBY_EVENT_RESCUE
Encountered a rescue statement.
Definition event.h:61
rb_str_new2
#define rb_str_new2
Old name of rb_str_new_cstr.
Definition string.h:1675
ALLOCV
#define ALLOCV
Old name of RB_ALLOCV.
Definition memory.h:404
ALLOC
#define ALLOC
Old name of RB_ALLOC.
Definition memory.h:400
RFLOAT_VALUE
#define RFLOAT_VALUE
Old name of rb_float_value.
Definition double.h:28
T_STRING
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
xfree
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
Qundef
#define Qundef
Old name of RUBY_Qundef.
Definition special_consts.h:62
INT2FIX
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
rb_str_cat2
#define rb_str_cat2
Old name of rb_str_cat_cstr.
Definition string.h:1683
ID2SYM
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
OBJ_FREEZE
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
Definition fl_type.h:135
ULONG2NUM
#define ULONG2NUM
Old name of RB_ULONG2NUM.
Definition long.h:60
FIXABLE
#define FIXABLE
Old name of RB_FIXABLE.
Definition fixnum.h:25
xmalloc
#define xmalloc
Old name of ruby_xmalloc.
Definition xmalloc.h:53
LONG2FIX
#define LONG2FIX
Old name of RB_INT2FIX.
Definition long.h:49
ZALLOC_N
#define ZALLOC_N
Old name of RB_ZALLOC_N.
Definition memory.h:401
T_HASH
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
ALLOC_N
#define ALLOC_N
Old name of RB_ALLOC_N.
Definition memory.h:399
rb_exc_new3
#define rb_exc_new3
Old name of rb_exc_new_str.
Definition error.h:38
Qtrue
#define Qtrue
Old name of RUBY_Qtrue.
Definition special_consts.h:61
INT2NUM
#define INT2NUM
Old name of RB_INT2NUM.
Definition int.h:43
Qnil
#define Qnil
Old name of RUBY_Qnil.
Definition special_consts.h:60
Qfalse
#define Qfalse
Old name of RUBY_Qfalse.
Definition special_consts.h:59
T_ARRAY
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
NIL_P
#define NIL_P
Old name of RB_NIL_P.
Definition special_consts.h:55
DBL2NUM
#define DBL2NUM
Old name of rb_float_new.
Definition double.h:29
xcalloc
#define xcalloc
Old name of ruby_xcalloc.
Definition xmalloc.h:55
NUM2LONG
#define NUM2LONG
Old name of RB_NUM2LONG.
Definition long.h:51
UINT2NUM
#define UINT2NUM
Old name of RB_UINT2NUM.
Definition int.h:46
CONST_ID
#define CONST_ID
Old name of RUBY_CONST_ID.
Definition symbol.h:47
ruby_debug
#define ruby_debug
This variable controls whether the interpreter is in debug mode.
Definition error.h:486
rb_eNotImpError
VALUE rb_eNotImpError
NotImplementedError exception.
Definition error.c:1440
rb_eStandardError
VALUE rb_eStandardError
StandardError exception.
Definition error.c:1427
rb_eLoadError
VALUE rb_eLoadError
LoadError exception.
Definition error.c:1448
rb_eTypeError
VALUE rb_eTypeError
TypeError exception.
Definition error.c:1430
rb_eNoMatchingPatternError
VALUE rb_eNoMatchingPatternError
NoMatchingPatternError exception.
Definition error.c:1443
rb_warn
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:466
rb_exc_new
VALUE rb_exc_new(VALUE etype, const char *ptr, long len)
Creates an instance of the passed exception class.
Definition error.c:1468
rb_eNoMatchingPatternKeyError
VALUE rb_eNoMatchingPatternKeyError
NoMatchingPatternKeyError exception.
Definition error.c:1444
rb_exc_new_str
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
Definition error.c:1481
rb_errinfo
VALUE rb_errinfo(void)
This is the same as $! in Ruby.
Definition eval.c:1941
rb_eSyntaxError
VALUE rb_eSyntaxError
SyntaxError exception.
Definition error.c:1447
rb_syserr_new
VALUE rb_syserr_new(int n, const char *mesg)
Creates an exception object that represents the given C errno.
Definition error.c:3863
rb_cArray
VALUE rb_cArray
Array class.
Definition array.c:40
rb_obj_hide
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
Definition object.c:104
rb_stdin
VALUE rb_stdin
STDIN constant.
Definition io.c:201
rb_obj_freeze
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
Definition object.c:1260
RB_OBJ_WRITTEN
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
Definition gc.h:615
RB_OBJ_WRITE
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Definition gc.h:603
rb_utf8_encoding
rb_encoding * rb_utf8_encoding(void)
Queries the encoding that represents UTF-8.
Definition encoding.c:1475
rb_ascii8bit_encoding
rb_encoding * rb_ascii8bit_encoding(void)
Queries the encoding that represents ASCII-8BIT a.k.a.
Definition encoding.c:1463
rb_usascii_encoding
rb_encoding * rb_usascii_encoding(void)
Queries the encoding that represents US-ASCII.
Definition encoding.c:1487
rb_enc_str_coderange
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
Definition string.c:905
rb_enc_interned_str
VALUE rb_enc_interned_str(const char *ptr, long len, rb_encoding *enc)
Identical to rb_enc_str_new(), except it returns a "f"string.
Definition string.c:12528
rb_enc_str_new_cstr
VALUE rb_enc_str_new_cstr(const char *ptr, rb_encoding *enc)
Identical to rb_enc_str_new(), except it assumes the passed pointer is a pointer to a C string.
Definition string.c:1103
rb_funcall
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
Definition vm_eval.c:1099
rb_ary_new
VALUE rb_ary_new(void)
Allocates a new, empty array.
Definition array.c:741
rb_hash_new
VALUE rb_hash_new(void)
Creates a new, empty hash object.
Definition hash.c:1477
rb_io_fdopen
VALUE rb_io_fdopen(int fd, int flags, const char *path)
Creates an IO instance whose backend is the given file descriptor.
Definition io.c:9338
rb_range_new
VALUE rb_range_new(VALUE beg, VALUE end, int excl)
Creates a new Range.
Definition range.c:68
rb_rational_new
VALUE rb_rational_new(VALUE num, VALUE den)
Constructs a Rational, with reduction.
Definition rational.c:1974
rb_str_append
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
Definition string.c:3681
rb_str_tmp_new
VALUE rb_str_tmp_new(long len)
Allocates a "temporary" string.
Definition string.c:1676
rb_str_new
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
Definition string.h:1498
rb_exc_new_cstr
#define rb_exc_new_cstr(exc, str)
Identical to rb_exc_new(), except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1670
rb_str_buf_new_cstr
#define rb_str_buf_new_cstr(str)
Identical to rb_str_new_cstr, except done differently.
Definition string.h:1639
rb_str_concat
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
Definition string.c:3923
rb_str_freeze
VALUE rb_str_freeze(VALUE str)
This is the implementation of String#freeze.
Definition string.c:3181
rb_str_new_cstr
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1514
rb_ivar_set
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1939
rb_const_get_at
VALUE rb_const_get_at(VALUE space, ID name)
Identical to rb_const_defined_at(), except it returns the actual defined value.
Definition variable.c:3237
rb_const_defined_at
int rb_const_defined_at(VALUE space, ID name)
Identical to rb_const_defined(), except it doesn't look for parent classes.
Definition variable.c:3559
rb_intern_const
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
Definition symbol.h:284
rb_id2sym
VALUE rb_id2sym(ID id)
Allocates an instance of rb_cSymbol that has the given id.
Definition symbol.c:952
rb_sym2str
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
Definition symbol.c:971
RUBY_IO_READABLE
@ RUBY_IO_READABLE
IO::READABLE
Definition io.h:82
rb_io_wait
VALUE rb_io_wait(VALUE io, VALUE events, VALUE timeout)
Blocks until the passed IO is ready for the passed events.
Definition io.c:1453
len
int len
Length of the buffer.
Definition io.h:8
rb_ractor_make_shareable
VALUE rb_ractor_make_shareable(VALUE obj)
Destructively transforms the passed object so that multiple Ractors can share it.
Definition ractor.c:3116
DECIMAL_SIZE_OF
#define DECIMAL_SIZE_OF(expr)
An approximation of decimal representation size.
Definition util.h:48
RB_INT2NUM
#define RB_INT2NUM
Just another name of rb_int2num_inline.
Definition int.h:37
RB_GC_GUARD
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
ruby::backward::cxxanyargs::type
VALUE type(ANYARGS)
ANYARGS-ed function type.
Definition cxxanyargs.hpp:56
pm_options_t
struct pm_options pm_options_t
The options that can be passed to the parser.
pm_parser_t
struct pm_parser pm_parser_t
The parser used to parse Ruby source.
Definition parser.h:267
pm_constant_id_t
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
Definition pm_constant_pool.h:31
pm_list_node_t
struct pm_list_node pm_list_node_t
This struct represents an abstract linked list that provides common functionality.
pm_string_init_result_t
pm_string_init_result_t
Represents the result of calling pm_string_mapped_init or pm_string_file_init.
Definition pm_string.h:105
PM_STRING_INIT_SUCCESS
@ PM_STRING_INIT_SUCCESS
Indicates that the string was successfully initialized.
Definition pm_string.h:107
PM_STRING_INIT_ERROR_GENERIC
@ PM_STRING_INIT_ERROR_GENERIC
Indicates a generic error from a string_*_init function, where the type of error should be read from ...
Definition pm_string.h:112
PM_STRING_INIT_ERROR_DIRECTORY
@ PM_STRING_INIT_ERROR_DIRECTORY
Indicates that the file that was attempted to be opened was a directory.
Definition pm_string.h:116
PM_ENCODING_US_ASCII_ENTRY
#define PM_ENCODING_US_ASCII_ENTRY
This is the US-ASCII encoding.
Definition encoding.h:252
PM_NODE_LIST_FOREACH
#define PM_NODE_LIST_FOREACH(list, index, node)
Loop through each node in the node list, writing each node to the given pm_node_t pointer.
Definition node.h:17
prism.h
The main header file for the prism parser.
RARRAY_LEN
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
RARRAY_AREF
#define RARRAY_AREF(a, i)
Definition rarray.h:403
RARRAY_CONST_PTR
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
Definition rarray.h:52
errno
#define errno
Ractor-aware version of errno.
Definition ruby.h:388
RTEST
#define RTEST
This is an old name of RB_TEST.
Definition special_consts.h:51
default_encoding
Definition encoding.c:1542
ensure_range
Definition compile.c:115
iseq_compile_data_ensure_node_stack
Definition compile.c:121
pm_alias_global_variable_node::old_name
struct pm_node * old_name
AliasGlobalVariableNode::old_name.
Definition ast.h:1129
pm_alias_global_variable_node::new_name
struct pm_node * new_name
AliasGlobalVariableNode::new_name.
Definition ast.h:1119
pm_alias_method_node::old_name
struct pm_node * old_name
AliasMethodNode::old_name.
Definition ast.h:1189
pm_alias_method_node::new_name
struct pm_node * new_name
AliasMethodNode::new_name.
Definition ast.h:1173
pm_alternation_pattern_node::left
struct pm_node * left
AlternationPatternNode::left.
Definition ast.h:1227
pm_alternation_pattern_node::right
struct pm_node * right
AlternationPatternNode::right.
Definition ast.h:1237
pm_and_node::left
struct pm_node * left
AndNode::left.
Definition ast.h:1278
pm_and_node::right
struct pm_node * right
AndNode::right.
Definition ast.h:1291
pm_arguments_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1325
pm_arguments_node::arguments
struct pm_node_list arguments
ArgumentsNode::arguments.
Definition ast.h:1336
pm_array_node::elements
struct pm_node_list elements
ArrayNode::elements.
Definition ast.h:1364
pm_array_pattern_node::requireds
struct pm_node_list requireds
ArrayPatternNode::requireds.
Definition ast.h:1444
pm_array_pattern_node::rest
struct pm_node * rest
ArrayPatternNode::rest.
Definition ast.h:1454
pm_array_pattern_node::constant
struct pm_node * constant
ArrayPatternNode::constant.
Definition ast.h:1434
pm_array_pattern_node::posts
struct pm_node_list posts
ArrayPatternNode::posts.
Definition ast.h:1464
pm_assoc_node::value
struct pm_node * value
AssocNode::value.
Definition ast.h:1531
pm_assoc_node::key
struct pm_node * key
AssocNode::key.
Definition ast.h:1518
pm_assoc_splat_node::value
struct pm_node * value
AssocSplatNode::value.
Definition ast.h:1569
pm_back_reference_read_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1596
pm_begin_node::ensure_clause
struct pm_ensure_node * ensure_clause
BeginNode::ensure_clause.
Definition ast.h:1678
pm_begin_node::rescue_clause
struct pm_rescue_node * rescue_clause
BeginNode::rescue_clause.
Definition ast.h:1658
pm_begin_node::statements
struct pm_statements_node * statements
BeginNode::statements.
Definition ast.h:1648
pm_begin_node::else_clause
struct pm_else_node * else_clause
BeginNode::else_clause.
Definition ast.h:1668
pm_block_argument_node::expression
struct pm_node * expression
BlockArgumentNode::expression.
Definition ast.h:1716
pm_block_node::parameters
struct pm_node * parameters
BlockNode::parameters.
Definition ast.h:1799
pm_block_node::body
struct pm_node * body
BlockNode::body.
Definition ast.h:1809
pm_block_node::locals
pm_constant_id_list_t locals
BlockNode::locals.
Definition ast.h:1785
pm_break_node::arguments
struct pm_arguments_node * arguments
BreakNode::arguments.
Definition ast.h:1989
pm_buffer_t
A pm_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
Definition pm_buffer.h:22
pm_call_and_write_node::value
struct pm_node * value
CallAndWriteNode::value.
Definition ast.h:2093
pm_call_and_write_node::read_name
pm_constant_id_t read_name
CallAndWriteNode::read_name.
Definition ast.h:2063
pm_call_and_write_node::write_name
pm_constant_id_t write_name
CallAndWriteNode::write_name.
Definition ast.h:2073
pm_call_and_write_node::receiver
struct pm_node * receiver
CallAndWriteNode::receiver.
Definition ast.h:2033
pm_call_node::closing_loc
pm_location_t closing_loc
CallNode::closing_loc.
Definition ast.h:2210
pm_call_node::receiver
struct pm_node * receiver
CallNode::receiver.
Definition ast.h:2148
pm_call_node::name
pm_constant_id_t name
CallNode::name.
Definition ast.h:2171
pm_call_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2131
pm_call_node::message_loc
pm_location_t message_loc
CallNode::message_loc.
Definition ast.h:2181
pm_call_node::arguments
struct pm_arguments_node * arguments
CallNode::arguments.
Definition ast.h:2200
pm_call_node::block
struct pm_node * block
CallNode::block.
Definition ast.h:2220
pm_call_operator_write_node::read_name
pm_constant_id_t read_name
CallOperatorWriteNode::read_name.
Definition ast.h:2284
pm_call_operator_write_node::binary_operator
pm_constant_id_t binary_operator
CallOperatorWriteNode::binary_operator.
Definition ast.h:2304
pm_call_operator_write_node::receiver
struct pm_node * receiver
CallOperatorWriteNode::receiver.
Definition ast.h:2254
pm_call_operator_write_node::write_name
pm_constant_id_t write_name
CallOperatorWriteNode::write_name.
Definition ast.h:2294
pm_call_operator_write_node::value
struct pm_node * value
CallOperatorWriteNode::value.
Definition ast.h:2324
pm_call_or_write_node::receiver
struct pm_node * receiver
CallOrWriteNode::receiver.
Definition ast.h:2358
pm_call_or_write_node::value
struct pm_node * value
CallOrWriteNode::value.
Definition ast.h:2418
pm_call_or_write_node::write_name
pm_constant_id_t write_name
CallOrWriteNode::write_name.
Definition ast.h:2398
pm_call_or_write_node::read_name
pm_constant_id_t read_name
CallOrWriteNode::read_name.
Definition ast.h:2388
pm_call_target_node::name
pm_constant_id_t name
CallTargetNode::name.
Definition ast.h:2480
pm_call_target_node::receiver
struct pm_node * receiver
CallTargetNode::receiver.
Definition ast.h:2460
pm_capture_pattern_node::target
struct pm_local_variable_target_node * target
CapturePatternNode::target.
Definition ast.h:2528
pm_capture_pattern_node::value
struct pm_node * value
CapturePatternNode::value.
Definition ast.h:2518
pm_case_match_node::conditions
struct pm_node_list conditions
CaseMatchNode::conditions.
Definition ast.h:2578
pm_case_match_node::else_clause
struct pm_else_node * else_clause
CaseMatchNode::else_clause.
Definition ast.h:2588
pm_case_match_node::predicate
struct pm_node * predicate
CaseMatchNode::predicate.
Definition ast.h:2568
pm_case_node::predicate
struct pm_node * predicate
CaseNode::predicate.
Definition ast.h:2638
pm_case_node::else_clause
struct pm_else_node * else_clause
CaseNode::else_clause.
Definition ast.h:2658
pm_case_node::conditions
struct pm_node_list conditions
CaseNode::conditions.
Definition ast.h:2648
pm_class_node::constant_path
struct pm_node * constant_path
ClassNode::constant_path.
Definition ast.h:2716
pm_class_node::locals
pm_constant_id_list_t locals
ClassNode::locals.
Definition ast.h:2701
pm_class_node::name
pm_constant_id_t name
ClassNode::name.
Definition ast.h:2766
pm_class_node::body
struct pm_node * body
ClassNode::body.
Definition ast.h:2747
pm_class_node::superclass
struct pm_node * superclass
ClassNode::superclass.
Definition ast.h:2736
pm_class_variable_and_write_node::value
struct pm_node * value
ClassVariableAndWriteNode::value.
Definition ast.h:2824
pm_class_variable_and_write_node::name
pm_constant_id_t name
ClassVariableAndWriteNode::name.
Definition ast.h:2794
pm_class_variable_operator_write_node::name
pm_constant_id_t name
ClassVariableOperatorWriteNode::name.
Definition ast.h:2847
pm_class_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ClassVariableOperatorWriteNode::binary_operator.
Definition ast.h:2867
pm_class_variable_operator_write_node::value
struct pm_node * value
ClassVariableOperatorWriteNode::value.
Definition ast.h:2862
pm_class_variable_or_write_node::name
pm_constant_id_t name
ClassVariableOrWriteNode::name.
Definition ast.h:2890
pm_class_variable_or_write_node::value
struct pm_node * value
ClassVariableOrWriteNode::value.
Definition ast.h:2905
pm_class_variable_read_node::name
pm_constant_id_t name
ClassVariableReadNode::name.
Definition ast.h:2934
pm_class_variable_target_node::name
pm_constant_id_t name
ClassVariableTargetNode::name.
Definition ast.h:2957
pm_class_variable_write_node::value
struct pm_node * value
ClassVariableWriteNode::value.
Definition ast.h:3009
pm_class_variable_write_node::name
pm_constant_id_t name
ClassVariableWriteNode::name.
Definition ast.h:2986
pm_constant_and_write_node::name_loc
pm_location_t name_loc
ConstantAndWriteNode::name_loc.
Definition ast.h:3047
pm_constant_and_write_node::name
pm_constant_id_t name
ConstantAndWriteNode::name.
Definition ast.h:3042
pm_constant_and_write_node::value
struct pm_node * value
ConstantAndWriteNode::value.
Definition ast.h:3057
pm_constant_id_list_t
A list of constant IDs.
Definition pm_constant_pool.h:36
pm_constant_id_list_t::size
size_t size
The number of constant ids in the list.
Definition pm_constant_pool.h:38
pm_constant_id_list_t::capacity
size_t capacity
The number of constant ids that have been allocated in the list.
Definition pm_constant_pool.h:41
pm_constant_id_list_t::ids
pm_constant_id_t * ids
The constant ids in the list.
Definition pm_constant_pool.h:44
pm_constant_operator_write_node::name
pm_constant_id_t name
ConstantOperatorWriteNode::name.
Definition ast.h:3080
pm_constant_operator_write_node::name_loc
pm_location_t name_loc
ConstantOperatorWriteNode::name_loc.
Definition ast.h:3085
pm_constant_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantOperatorWriteNode::binary_operator.
Definition ast.h:3100
pm_constant_operator_write_node::value
struct pm_node * value
ConstantOperatorWriteNode::value.
Definition ast.h:3095
pm_constant_or_write_node::name_loc
pm_location_t name_loc
ConstantOrWriteNode::name_loc.
Definition ast.h:3128
pm_constant_or_write_node::name
pm_constant_id_t name
ConstantOrWriteNode::name.
Definition ast.h:3123
pm_constant_or_write_node::value
struct pm_node * value
ConstantOrWriteNode::value.
Definition ast.h:3138
pm_constant_path_and_write_node::target
struct pm_constant_path_node * target
ConstantPathAndWriteNode::target.
Definition ast.h:3161
pm_constant_path_and_write_node::value
struct pm_node * value
ConstantPathAndWriteNode::value.
Definition ast.h:3171
pm_constant_path_node::name
pm_constant_id_t name
ConstantPathNode::name.
Definition ast.h:3212
pm_constant_path_node::parent
struct pm_node * parent
ConstantPathNode::parent.
Definition ast.h:3205
pm_constant_path_operator_write_node::target
struct pm_constant_path_node * target
ConstantPathOperatorWriteNode::target.
Definition ast.h:3261
pm_constant_path_operator_write_node::value
struct pm_node * value
ConstantPathOperatorWriteNode::value.
Definition ast.h:3271
pm_constant_path_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantPathOperatorWriteNode::binary_operator.
Definition ast.h:3276
pm_constant_path_or_write_node::value
struct pm_node * value
ConstantPathOrWriteNode::value.
Definition ast.h:3309
pm_constant_path_or_write_node::target
struct pm_constant_path_node * target
ConstantPathOrWriteNode::target.
Definition ast.h:3299
pm_constant_path_target_node::parent
struct pm_node * parent
ConstantPathTargetNode::parent.
Definition ast.h:3332
pm_constant_path_target_node::name
pm_constant_id_t name
ConstantPathTargetNode::name.
Definition ast.h:3337
pm_constant_path_write_node::target
struct pm_constant_path_node * target
ConstantPathWriteNode::target.
Definition ast.h:3384
pm_constant_path_write_node::value
struct pm_node * value
ConstantPathWriteNode::value.
Definition ast.h:3404
pm_constant_pool_t::size
uint32_t size
The number of buckets in the hash map.
Definition pm_constant_pool.h:142
pm_constant_pool_t::constants
pm_constant_t * constants
The constants that are stored in the buckets.
Definition pm_constant_pool.h:139
pm_constant_read_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3421
pm_constant_read_node::name
pm_constant_id_t name
ConstantReadNode::name.
Definition ast.h:3433
pm_constant_t
A constant in the pool which effectively stores a string.
Definition pm_constant_pool.h:125
pm_constant_t::length
size_t length
The length of the string.
Definition pm_constant_pool.h:130
pm_constant_t::start
const uint8_t * start
A pointer to the start of the string.
Definition pm_constant_pool.h:127
pm_constant_target_node::name
pm_constant_id_t name
ConstantTargetNode::name.
Definition ast.h:3456
pm_constant_write_node::value
struct pm_node * value
ConstantWriteNode::value.
Definition ast.h:3508
pm_constant_write_node::name
pm_constant_id_t name
ConstantWriteNode::name.
Definition ast.h:3485
pm_def_node::parameters
struct pm_parameters_node * parameters
DefNode::parameters.
Definition ast.h:3557
pm_def_node::name
pm_constant_id_t name
DefNode::name.
Definition ast.h:3542
pm_def_node::body
struct pm_node * body
DefNode::body.
Definition ast.h:3562
pm_def_node::receiver
struct pm_node * receiver
DefNode::receiver.
Definition ast.h:3552
pm_def_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3536
pm_def_node::locals
pm_constant_id_list_t locals
DefNode::locals.
Definition ast.h:3567
pm_defined_node::value
struct pm_node * value
DefinedNode::value.
Definition ast.h:3625
pm_diagnostic_t
This struct represents a diagnostic generated during parsing.
Definition diagnostic.h:363
pm_diagnostic_t::location
pm_location_t location
The location of the diagnostic in the source.
Definition diagnostic.h:368
pm_diagnostic_t::message
const char * message
The message associated with the diagnostic.
Definition diagnostic.h:374
pm_diagnostic_t::node
pm_list_node_t node
The embedded base node.
Definition diagnostic.h:365
pm_diagnostic_t::level
uint8_t level
The level of the diagnostic, see pm_error_level_t and pm_warning_level_t for possible values.
Definition diagnostic.h:387
pm_else_node::statements
struct pm_statements_node * statements
ElseNode::statements.
Definition ast.h:3663
pm_embedded_statements_node::statements
struct pm_statements_node * statements
EmbeddedStatementsNode::statements.
Definition ast.h:3696
pm_embedded_variable_node::variable
struct pm_node * variable
EmbeddedVariableNode::variable.
Definition ast.h:3729
pm_encoding_t
This struct defines the functions necessary to implement the encoding interface so we can determine h...
Definition encoding.h:23
pm_encoding_t::char_width
size_t(* char_width)(const uint8_t *b, ptrdiff_t n)
Return the number of bytes that the next character takes if it is valid in the encoding.
Definition encoding.h:29
pm_encoding_t::name
const char * name
The name of the encoding.
Definition encoding.h:56
pm_ensure_node::statements
struct pm_statements_node * statements
EnsureNode::statements.
Definition ast.h:3761
pm_find_pattern_node::constant
struct pm_node * constant
FindPatternNode::constant.
Definition ast.h:3821
pm_find_pattern_node::right
struct pm_node * right
FindPatternNode::right.
Definition ast.h:3860
pm_find_pattern_node::requireds
struct pm_node_list requireds
FindPatternNode::requireds.
Definition ast.h:3847
pm_find_pattern_node::left
struct pm_splat_node * left
FindPatternNode::left.
Definition ast.h:3834
pm_flip_flop_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3906
pm_flip_flop_node::left
struct pm_node * left
FlipFlopNode::left.
Definition ast.h:3912
pm_flip_flop_node::right
struct pm_node * right
FlipFlopNode::right.
Definition ast.h:3917
pm_float_node::value
double value
FloatNode::value.
Definition ast.h:3947
pm_for_node::statements
struct pm_statements_node * statements
ForNode::statements.
Definition ast.h:3997
pm_for_node::collection
struct pm_node * collection
ForNode::collection.
Definition ast.h:3985
pm_forwarding_super_node::block
struct pm_block_node * block
ForwardingSuperNode::block.
Definition ast.h:4099
pm_global_variable_and_write_node::value
struct pm_node * value
GlobalVariableAndWriteNode::value.
Definition ast.h:4137
pm_global_variable_and_write_node::name
pm_constant_id_t name
GlobalVariableAndWriteNode::name.
Definition ast.h:4122
pm_global_variable_operator_write_node::name
pm_constant_id_t name
GlobalVariableOperatorWriteNode::name.
Definition ast.h:4160
pm_global_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
GlobalVariableOperatorWriteNode::binary_operator.
Definition ast.h:4180
pm_global_variable_operator_write_node::value
struct pm_node * value
GlobalVariableOperatorWriteNode::value.
Definition ast.h:4175
pm_global_variable_or_write_node::name
pm_constant_id_t name
GlobalVariableOrWriteNode::name.
Definition ast.h:4203
pm_global_variable_or_write_node::value
struct pm_node * value
GlobalVariableOrWriteNode::value.
Definition ast.h:4218
pm_global_variable_read_node::name
pm_constant_id_t name
GlobalVariableReadNode::name.
Definition ast.h:4247
pm_global_variable_target_node::name
pm_constant_id_t name
GlobalVariableTargetNode::name.
Definition ast.h:4270
pm_global_variable_write_node::value
struct pm_node * value
GlobalVariableWriteNode::value.
Definition ast.h:4322
pm_global_variable_write_node::name
pm_constant_id_t name
GlobalVariableWriteNode::name.
Definition ast.h:4299
pm_hash_node::elements
struct pm_node_list elements
HashNode::elements.
Definition ast.h:4373
pm_hash_pattern_node::elements
struct pm_node_list elements
HashPatternNode::elements.
Definition ast.h:4433
pm_hash_pattern_node::rest
struct pm_node * rest
HashPatternNode::rest.
Definition ast.h:4449
pm_hash_pattern_node::constant
struct pm_node * constant
HashPatternNode::constant.
Definition ast.h:4423
pm_if_node::predicate
struct pm_node * predicate
IfNode::predicate.
Definition ast.h:4529
pm_if_node::statements
struct pm_statements_node * statements
IfNode::statements.
Definition ast.h:4556
pm_imaginary_node::numeric
struct pm_node * numeric
ImaginaryNode::numeric.
Definition ast.h:4610
pm_implicit_node::value
struct pm_node * value
ImplicitNode::value.
Definition ast.h:4639
pm_in_node::statements
struct pm_statements_node * statements
InNode::statements.
Definition ast.h:4694
pm_in_node::pattern
struct pm_node * pattern
InNode::pattern.
Definition ast.h:4689
pm_index_and_write_node::arguments
struct pm_arguments_node * arguments
IndexAndWriteNode::arguments.
Definition ast.h:4748
pm_index_and_write_node::receiver
struct pm_node * receiver
IndexAndWriteNode::receiver.
Definition ast.h:4733
pm_index_and_write_node::block
struct pm_block_argument_node * block
IndexAndWriteNode::block.
Definition ast.h:4758
pm_index_and_write_node::value
struct pm_node * value
IndexAndWriteNode::value.
Definition ast.h:4768
pm_index_operator_write_node::block
struct pm_block_argument_node * block
IndexOperatorWriteNode::block.
Definition ast.h:4822
pm_index_operator_write_node::value
struct pm_node * value
IndexOperatorWriteNode::value.
Definition ast.h:4837
pm_index_operator_write_node::arguments
struct pm_arguments_node * arguments
IndexOperatorWriteNode::arguments.
Definition ast.h:4812
pm_index_operator_write_node::binary_operator
pm_constant_id_t binary_operator
IndexOperatorWriteNode::binary_operator.
Definition ast.h:4827
pm_index_operator_write_node::receiver
struct pm_node * receiver
IndexOperatorWriteNode::receiver.
Definition ast.h:4797
pm_index_or_write_node::block
struct pm_block_argument_node * block
IndexOrWriteNode::block.
Definition ast.h:4891
pm_index_or_write_node::receiver
struct pm_node * receiver
IndexOrWriteNode::receiver.
Definition ast.h:4866
pm_index_or_write_node::value
struct pm_node * value
IndexOrWriteNode::value.
Definition ast.h:4901
pm_index_or_write_node::arguments
struct pm_arguments_node * arguments
IndexOrWriteNode::arguments.
Definition ast.h:4881
pm_index_target_node::receiver
struct pm_node * receiver
IndexTargetNode::receiver.
Definition ast.h:4938
pm_index_target_node::arguments
struct pm_arguments_node * arguments
IndexTargetNode::arguments.
Definition ast.h:4948
pm_index_target_node::block
struct pm_block_argument_node * block
IndexTargetNode::block.
Definition ast.h:4958
pm_instance_variable_and_write_node::value
struct pm_node * value
InstanceVariableAndWriteNode::value.
Definition ast.h:4996
pm_instance_variable_and_write_node::name
pm_constant_id_t name
InstanceVariableAndWriteNode::name.
Definition ast.h:4981
pm_instance_variable_operator_write_node::value
struct pm_node * value
InstanceVariableOperatorWriteNode::value.
Definition ast.h:5034
pm_instance_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
InstanceVariableOperatorWriteNode::binary_operator.
Definition ast.h:5039
pm_instance_variable_operator_write_node::name
pm_constant_id_t name
InstanceVariableOperatorWriteNode::name.
Definition ast.h:5019
pm_instance_variable_or_write_node::value
struct pm_node * value
InstanceVariableOrWriteNode::value.
Definition ast.h:5077
pm_instance_variable_or_write_node::name
pm_constant_id_t name
InstanceVariableOrWriteNode::name.
Definition ast.h:5062
pm_instance_variable_read_node::name
pm_constant_id_t name
InstanceVariableReadNode::name.
Definition ast.h:5106
pm_instance_variable_target_node::name
pm_constant_id_t name
InstanceVariableTargetNode::name.
Definition ast.h:5129
pm_instance_variable_write_node::name
pm_constant_id_t name
InstanceVariableWriteNode::name.
Definition ast.h:5158
pm_instance_variable_write_node::value
struct pm_node * value
InstanceVariableWriteNode::value.
Definition ast.h:5181
pm_integer_node::value
pm_integer_t value
IntegerNode::value.
Definition ast.h:5222
pm_integer_t
A structure represents an arbitrary-sized integer.
Definition pm_integer.h:20
pm_integer_t::length
size_t length
The number of allocated values.
Definition pm_integer.h:25
pm_integer_t::value
uint32_t value
Embedded value for small integer.
Definition pm_integer.h:36
pm_integer_t::values
uint32_t * values
List of 32-bit integers.
Definition pm_integer.h:30
pm_integer_t::negative
bool negative
Whether or not the integer is negative.
Definition pm_integer.h:42
pm_interpolated_string_node::parts
struct pm_node_list parts
InterpolatedStringNode::parts.
Definition ast.h:5346
pm_interpolated_symbol_node::parts
struct pm_node_list parts
InterpolatedSymbolNode::parts.
Definition ast.h:5379
pm_interpolated_x_string_node::parts
struct pm_node_list parts
InterpolatedXStringNode::parts.
Definition ast.h:5412
pm_keyword_hash_node::elements
struct pm_node_list elements
KeywordHashNode::elements.
Definition ast.h:5479
pm_lambda_node::body
struct pm_node * body
LambdaNode::body.
Definition ast.h:5564
pm_lambda_node::opening_loc
pm_location_t opening_loc
LambdaNode::opening_loc.
Definition ast.h:5549
pm_lambda_node::parameters
struct pm_node * parameters
LambdaNode::parameters.
Definition ast.h:5559
pm_lambda_node::operator_loc
pm_location_t operator_loc
LambdaNode::operator_loc.
Definition ast.h:5544
pm_lambda_node::locals
pm_constant_id_list_t locals
LambdaNode::locals.
Definition ast.h:5539
pm_line_column_t
A line and column in a string.
Definition pm_newline_list.h:45
pm_line_column_t::column
uint32_t column
The column number.
Definition pm_newline_list.h:50
pm_line_column_t::line
int32_t line
The line number.
Definition pm_newline_list.h:47
pm_list_node::next
struct pm_list_node * next
A pointer to the next node in the list.
Definition pm_list.h:48
pm_list_t
This represents the overall linked list.
Definition pm_list.h:55
pm_list_t::head
pm_list_node_t * head
A pointer to the head of the list.
Definition pm_list.h:60
pm_list_t::size
size_t size
The size of the list.
Definition pm_list.h:57
pm_local_table_insert_ctx
Definition prism_compile.c:4580
pm_local_variable_and_write_node::name
pm_constant_id_t name
LocalVariableAndWriteNode::name.
Definition ast.h:5602
pm_local_variable_and_write_node::depth
uint32_t depth
LocalVariableAndWriteNode::depth.
Definition ast.h:5607
pm_local_variable_and_write_node::value
struct pm_node * value
LocalVariableAndWriteNode::value.
Definition ast.h:5597
pm_local_variable_operator_write_node::depth
uint32_t depth
LocalVariableOperatorWriteNode::depth.
Definition ast.h:5655
pm_local_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
LocalVariableOperatorWriteNode::binary_operator.
Definition ast.h:5650
pm_local_variable_operator_write_node::value
struct pm_node * value
LocalVariableOperatorWriteNode::value.
Definition ast.h:5640
pm_local_variable_operator_write_node::name
pm_constant_id_t name
LocalVariableOperatorWriteNode::name.
Definition ast.h:5645
pm_local_variable_or_write_node::depth
uint32_t depth
LocalVariableOrWriteNode::depth.
Definition ast.h:5698
pm_local_variable_or_write_node::value
struct pm_node * value
LocalVariableOrWriteNode::value.
Definition ast.h:5688
pm_local_variable_or_write_node::name
pm_constant_id_t name
LocalVariableOrWriteNode::name.
Definition ast.h:5693
pm_local_variable_read_node::depth
uint32_t depth
LocalVariableReadNode::depth.
Definition ast.h:5744
pm_local_variable_read_node::name
pm_constant_id_t name
LocalVariableReadNode::name.
Definition ast.h:5731
pm_local_variable_target_node::depth
uint32_t depth
LocalVariableTargetNode::depth.
Definition ast.h:5775
pm_local_variable_target_node::name
pm_constant_id_t name
LocalVariableTargetNode::name.
Definition ast.h:5770
pm_local_variable_write_node::value
struct pm_node * value
LocalVariableWriteNode::value.
Definition ast.h:5844
pm_local_variable_write_node::depth
uint32_t depth
LocalVariableWriteNode::depth.
Definition ast.h:5817
pm_local_variable_write_node::name
pm_constant_id_t name
LocalVariableWriteNode::name.
Definition ast.h:5804
pm_location_t
This represents a range of bytes in the source string to which a node or token corresponds.
Definition ast.h:544
pm_location_t::start
const uint8_t * start
A pointer to the start location of the range in the source.
Definition ast.h:546
pm_location_t::end
const uint8_t * end
A pointer to the end location of the range in the source.
Definition ast.h:549
pm_match_predicate_node::pattern
struct pm_node * pattern
MatchPredicateNode::pattern.
Definition ast.h:5933
pm_match_predicate_node::value
struct pm_node * value
MatchPredicateNode::value.
Definition ast.h:5928
pm_match_required_node::value
struct pm_node * value
MatchRequiredNode::value.
Definition ast.h:5966
pm_match_required_node::pattern
struct pm_node * pattern
MatchRequiredNode::pattern.
Definition ast.h:6015
pm_match_write_node::targets
struct pm_node_list targets
MatchWriteNode::targets.
Definition ast.h:6053
pm_match_write_node::call
struct pm_call_node * call
MatchWriteNode::call.
Definition ast.h:6048
pm_module_node::constant_path
struct pm_node * constant_path
ModuleNode::constant_path.
Definition ast.h:6101
pm_module_node::body
struct pm_node * body
ModuleNode::body.
Definition ast.h:6106
pm_module_node::locals
pm_constant_id_list_t locals
ModuleNode::locals.
Definition ast.h:6091
pm_module_node::name
pm_constant_id_t name
ModuleNode::name.
Definition ast.h:6116
pm_multi_target_node::lefts
struct pm_node_list lefts
MultiTargetNode::lefts.
Definition ast.h:6154
pm_multi_target_node::rest
struct pm_node * rest
MultiTargetNode::rest.
Definition ast.h:6174
pm_multi_target_node::rights
struct pm_node_list rights
MultiTargetNode::rights.
Definition ast.h:6184
pm_multi_target_state_node
This is a node in the multi target state linked list.
Definition prism_compile.c:4765
pm_multi_target_state_t
As we're compiling a multi target, we need to track additional information whenever there is a parent...
Definition prism_compile.c:4791
pm_multi_write_node::value
struct pm_node * value
MultiWriteNode::value.
Definition ast.h:6307
pm_multi_write_node::rest
struct pm_node * rest
MultiWriteNode::rest.
Definition ast.h:6257
pm_multi_write_node::rights
struct pm_node_list rights
MultiWriteNode::rights.
Definition ast.h:6267
pm_multi_write_node::lefts
struct pm_node_list lefts
MultiWriteNode::lefts.
Definition ast.h:6237
pm_newline_list_t
A list of offsets of newlines in a string.
Definition pm_newline_list.h:28
pm_newline_list_t::start
const uint8_t * start
A pointer to the start of the source string.
Definition pm_newline_list.h:30
pm_newline_list_t::offsets
size_t * offsets
The list of offsets.
Definition pm_newline_list.h:39
pm_newline_list_t::size
size_t size
The number of offsets in the list.
Definition pm_newline_list.h:33
pm_next_node::arguments
struct pm_arguments_node * arguments
NextNode::arguments.
Definition ast.h:6330
pm_node_list::size
size_t size
The number of nodes in the list.
Definition ast.h:559
pm_node_list::nodes
struct pm_node ** nodes
The nodes in the list.
Definition ast.h:565
pm_node_location_t
This compiler defines its own concept of the location of a node.
Definition prism_compile.c:9
pm_node_location_t::line
int32_t line
This is the line number of a node.
Definition prism_compile.c:11
pm_node_location_t::node_id
uint32_t node_id
This is a unique identifier for the node.
Definition prism_compile.c:14
pm_node::type
pm_node_type_t type
This represents the type of the node.
Definition ast.h:1073
pm_node::node_id
uint32_t node_id
The unique identifier for this node, which is deterministic based on the source.
Definition ast.h:1085
pm_node::flags
pm_node_flags_t flags
This represents any flags on the node.
Definition ast.h:1079
pm_node::location
pm_location_t location
This is the location of the node in the source.
Definition ast.h:1091
pm_numbered_reference_read_node::number
uint32_t number
NumberedReferenceReadNode::number.
Definition ast.h:6436
pm_optional_keyword_parameter_node::name
pm_constant_id_t name
OptionalKeywordParameterNode::name.
Definition ast.h:6463
pm_optional_keyword_parameter_node::value
struct pm_node * value
OptionalKeywordParameterNode::value.
Definition ast.h:6473
pm_optional_parameter_node::value
struct pm_node * value
OptionalParameterNode::value.
Definition ast.h:6515
pm_optional_parameter_node::name
pm_constant_id_t name
OptionalParameterNode::name.
Definition ast.h:6500
pm_options::version
pm_options_version_t version
The version of prism that we should be parsing with.
Definition options.h:150
pm_or_node::left
struct pm_node * left
OrNode::left.
Definition ast.h:6546
pm_or_node::right
struct pm_node * right
OrNode::right.
Definition ast.h:6559
pm_parameters_node::rest
struct pm_node * rest
ParametersNode::rest.
Definition ast.h:6603
pm_parameters_node::requireds
struct pm_node_list requireds
ParametersNode::requireds.
Definition ast.h:6593
pm_parameters_node::block
struct pm_block_parameter_node * block
ParametersNode::block.
Definition ast.h:6623
pm_parameters_node::optionals
struct pm_node_list optionals
ParametersNode::optionals.
Definition ast.h:6598
pm_parameters_node::posts
struct pm_node_list posts
ParametersNode::posts.
Definition ast.h:6608
pm_parameters_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6587
pm_parameters_node::keyword_rest
struct pm_node * keyword_rest
ParametersNode::keyword_rest.
Definition ast.h:6618
pm_parameters_node::keywords
struct pm_node_list keywords
ParametersNode::keywords.
Definition ast.h:6613
pm_parentheses_node::body
struct pm_node * body
ParenthesesNode::body.
Definition ast.h:6649
pm_parse_error_format_t
The format that will be used to format the errors into the output.
Definition prism_compile.c:10535
pm_parse_error_format_t::blank_prefix_length
size_t blank_prefix_length
The length of the blank prefix.
Definition prism_compile.c:10546
pm_parse_error_format_t::blank_prefix
const char * blank_prefix
The prefix that will be used for blank lines.
Definition prism_compile.c:10540
pm_parse_error_format_t::divider_length
size_t divider_length
The length of the divider.
Definition prism_compile.c:10549
pm_parse_error_format_t::number_prefix
const char * number_prefix
The prefix that will be used for line numbers.
Definition prism_compile.c:10537
pm_parse_error_format_t::divider
const char * divider
The divider that will be used between sections of source code.
Definition prism_compile.c:10543
pm_parse_error_t
An error that is going to be formatted into the output.
Definition prism_compile.c:10520
pm_parse_error_t::error
pm_diagnostic_t * error
A pointer to the diagnostic that was generated during parsing.
Definition prism_compile.c:10522
pm_parse_error_t::column_end
uint32_t column_end
The column end of the diagnostic message.
Definition prism_compile.c:10531
pm_parse_error_t::line
int32_t line
The start line of the diagnostic message.
Definition prism_compile.c:10525
pm_parse_error_t::column_start
uint32_t column_start
The column start of the diagnostic message.
Definition prism_compile.c:10528
pm_parse_result_t
Definition prism_compile.h:69
pm_parse_result_t::parsed
bool parsed
Whether or not this parse result has performed its parsing yet.
Definition prism_compile.h:83
pm_parse_result_t::node
pm_scope_node_t node
The resulting scope node that will hold the generated AST.
Definition prism_compile.h:80
pm_parse_result_t::input
pm_string_t input
The input that represents the source to be parsed.
Definition prism_compile.h:77
pm_parse_result_t::parser
pm_parser_t parser
The parser that will do the actual parsing.
Definition prism_compile.h:71
pm_parse_result_t::options
pm_options_t options
The options that will be passed to the parser.
Definition prism_compile.h:74
pm_parser::encoding
const pm_encoding_t * encoding
The encoding functions for the current file is attached to the parser as it's parsing so that it can ...
Definition parser.h:755
pm_parser::end
const uint8_t * end
The pointer to the end of the source.
Definition parser.h:694
pm_parser::constant_pool
pm_constant_pool_t constant_pool
This constant pool keeps all of the constants defined throughout the file so that we can reference th...
Definition parser.h:786
pm_parser::start
const uint8_t * start
The pointer to the start of the source.
Definition parser.h:691
pm_parser::error_list
pm_list_t error_list
The list of errors that have been found while parsing.
Definition parser.h:734
pm_parser::warning_list
pm_list_t warning_list
The list of warnings that have been found while parsing.
Definition parser.h:731
pm_parser::start_line
int32_t start_line
The line number at the start of the parse.
Definition parser.h:809
pm_parser::filepath
pm_string_t filepath
This is the path of the file being parsed.
Definition parser.h:780
pm_parser::newline_list
pm_newline_list_t newline_list
This is the list of newline offsets in the source file.
Definition parser.h:789
pm_pinned_variable_node::variable
struct pm_node * variable
PinnedVariableNode::variable.
Definition ast.h:6745
pm_post_execution_node::statements
struct pm_statements_node * statements
PostExecutionNode::statements.
Definition ast.h:6778
pm_pre_execution_node::statements
struct pm_statements_node * statements
PreExecutionNode::statements.
Definition ast.h:6816
pm_program_node::statements
struct pm_statements_node * statements
ProgramNode::statements.
Definition ast.h:6856
pm_range_node::right
struct pm_node * right
RangeNode::right.
Definition ast.h:6907
pm_range_node::left
struct pm_node * left
RangeNode::left.
Definition ast.h:6893
pm_rational_node::denominator
pm_integer_t denominator
RationalNode::denominator.
Definition ast.h:6956
pm_rational_node::numerator
pm_integer_t numerator
RationalNode::numerator.
Definition ast.h:6947
pm_required_parameter_node::name
pm_constant_id_t name
RequiredParameterNode::name.
Definition ast.h:7084
pm_rescue_modifier_node::rescue_expression
struct pm_node * rescue_expression
RescueModifierNode::rescue_expression.
Definition ast.h:7117
pm_rescue_modifier_node::expression
struct pm_node * expression
RescueModifierNode::expression.
Definition ast.h:7107
pm_rescue_node::subsequent
struct pm_rescue_node * subsequent
RescueNode::subsequent.
Definition ast.h:7175
pm_rescue_node::reference
struct pm_node * reference
RescueNode::reference.
Definition ast.h:7160
pm_rescue_node::exceptions
struct pm_node_list exceptions
RescueNode::exceptions.
Definition ast.h:7150
pm_rescue_node::statements
struct pm_statements_node * statements
RescueNode::statements.
Definition ast.h:7170
pm_return_node::arguments
struct pm_arguments_node * arguments
ReturnNode::arguments.
Definition ast.h:7258
pm_scope_node::filepath_encoding
rb_encoding * filepath_encoding
This is the encoding of the actual filepath object that will be used when a FILE node is compiled or ...
Definition prism_compile.h:47
pm_scope_node::pre_execution_anchor
struct iseq_link_anchor * pre_execution_anchor
This will only be set on the top-level scope node.
Definition prism_compile.h:63
pm_scope_node::script_lines
VALUE * script_lines
This is a pointer to the list of script lines for the ISEQs that will be associated with this scope n...
Definition prism_compile.h:40
pm_shareable_constant_node::write
struct pm_node * write
ShareableConstantNode::write.
Definition ast.h:7307
pm_shareable_constant_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7299
pm_singleton_class_node::locals
pm_constant_id_list_t locals
SingletonClassNode::locals.
Definition ast.h:7330
pm_singleton_class_node::expression
struct pm_node * expression
SingletonClassNode::expression.
Definition ast.h:7345
pm_singleton_class_node::body
struct pm_node * body
SingletonClassNode::body.
Definition ast.h:7350
pm_source_file_node::filepath
pm_string_t filepath
SourceFileNode::filepath.
Definition ast.h:7404
pm_splat_node::expression
struct pm_node * expression
SplatNode::expression.
Definition ast.h:7450
pm_statements_node::body
struct pm_node_list body
StatementsNode::body.
Definition ast.h:7473
pm_statements_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7467
pm_string_node::unescaped
pm_string_t unescaped
StringNode::unescaped.
Definition ast.h:7523
pm_string_t
A generic string type that can have various ownership semantics.
Definition pm_string.h:33
pm_super_node::arguments
struct pm_arguments_node * arguments
SuperNode::arguments.
Definition ast.h:7559
pm_super_node::block
struct pm_node * block
SuperNode::block.
Definition ast.h:7569
pm_symbol_node::unescaped
pm_string_t unescaped
SymbolNode::unescaped.
Definition ast.h:7615
pm_symbol_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7594
pm_undef_node::names
struct pm_node_list names
UndefNode::names.
Definition ast.h:7656
pm_unless_node::statements
struct pm_statements_node * statements
UnlessNode::statements.
Definition ast.h:7729
pm_unless_node::predicate
struct pm_node * predicate
UnlessNode::predicate.
Definition ast.h:7708
pm_unless_node::else_clause
struct pm_else_node * else_clause
UnlessNode::else_clause.
Definition ast.h:7739
pm_until_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7772
pm_while_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7861
pm_x_string_node::unescaped
pm_string_t unescaped
XStringNode::unescaped.
Definition ast.h:7929
pm_yield_node::arguments
struct pm_arguments_node * arguments
YieldNode::arguments.
Definition ast.h:7962
rb_builtin_function
Definition builtin.h:6
rb_callinfo_kwarg
Definition vm_callinfo.h:48
rb_callinfo
Definition vm_callinfo.h:65
rb_iseq_constant_body
Definition vm_core.h:404
rb_iseq_constant_body::param
struct rb_iseq_constant_body::@000024342312237062266020177166377106262102236123 param
parameter information
rb_iseq_new_with_callback_callback_func
Definition vm_core.h:1233
rb_stdin_wrapper
Definition prism_compile.c:11435
ID
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
VALUE
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
RB_TYPE_P
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376