Ruby: prism_compile.c Source File

Ruby 4.0.5p0 (2026-05-20 revision 64336ffd0ee9e1f4c05891695a3d7b49cb709721)

prism_compile.c
1#include "prism.h"
2#include "ruby/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 update_lvar_state(iseq, level, idx);
106 if (level > 0) access_outer_variables(iseq, level, iseq_lvar_id(iseq, idx, level), Qtrue);
107}
108
109#define PUSH_GETLOCAL(seq, location, idx, level) \
110 pm_iseq_add_getlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
111
112#define PUSH_SETLOCAL(seq, location, idx, level) \
113 pm_iseq_add_setlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
114
115/******************************************************************************/
116/* These are helper macros for the compiler. */
117/******************************************************************************/
118
119#define OLD_ISEQ NEW_ISEQ
120#undef NEW_ISEQ
121
122#define NEW_ISEQ(node, name, type, line_no) \
123 pm_new_child_iseq(iseq, (node), rb_fstring(name), 0, (type), (line_no))
124
125#define OLD_CHILD_ISEQ NEW_CHILD_ISEQ
126#undef NEW_CHILD_ISEQ
127
128#define NEW_CHILD_ISEQ(node, name, type, line_no) \
129 pm_new_child_iseq(iseq, (node), rb_fstring(name), iseq, (type), (line_no))
130
131#define PM_COMPILE(node) \
132 pm_compile_node(iseq, (node), ret, popped, scope_node)
133
134#define PM_COMPILE_INTO_ANCHOR(_ret, node) \
135 pm_compile_node(iseq, (node), _ret, popped, scope_node)
136
137#define PM_COMPILE_POPPED(node) \
138 pm_compile_node(iseq, (node), ret, true, scope_node)
139
140#define PM_COMPILE_NOT_POPPED(node) \
141 pm_compile_node(iseq, (node), ret, false, scope_node)
142
143#define PM_NODE_START_LOCATION(parser, node) \
144 ((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 })
145
146#define PM_NODE_END_LOCATION(parser, node) \
147 ((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 })
148
149#define PM_LOCATION_START_LOCATION(parser, location, id) \
150 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, (location)->start, (parser)->start_line), .node_id = id })
151
152#define PM_NODE_START_LINE_COLUMN(parser, node) \
153 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.start, (parser)->start_line)
154
155#define PM_NODE_END_LINE_COLUMN(parser, node) \
156 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.end, (parser)->start_line)
157
158#define PM_LOCATION_START_LINE_COLUMN(parser, location) \
159 pm_newline_list_line_column(&(parser)->newline_list, (location)->start, (parser)->start_line)
160
161static int
162pm_node_line_number(const pm_parser_t *parser, const pm_node_t *node)
163{
164 return (int) pm_newline_list_line(&parser->newline_list, node->location.start, parser->start_line);
165}
166
167static int
168pm_location_line_number(const pm_parser_t *parser, const pm_location_t *location) {
169 return (int) pm_newline_list_line(&parser->newline_list, location->start, parser->start_line);
170}
171
175static VALUE
176parse_integer_value(const pm_integer_t *integer)
177{
178 VALUE result;
179
180 if (integer->values == NULL) {
181 result = UINT2NUM(integer->value);
182 }
183 else {
184 VALUE string = rb_str_new(NULL, integer->length * 8);
185 unsigned char *bytes = (unsigned char *) RSTRING_PTR(string);
186
187 size_t offset = integer->length * 8;
188 for (size_t value_index = 0; value_index < integer->length; value_index++) {
189 uint32_t value = integer->values[value_index];
190
191 for (int index = 0; index < 8; index++) {
192 int byte = (value >> (4 * index)) & 0xf;
193 bytes[--offset] = byte < 10 ? byte + '0' : byte - 10 + 'a';
194 }
195 }
196
197 result = rb_funcall(string, rb_intern("to_i"), 1, UINT2NUM(16));
198 }
199
200 if (integer->negative) {
201 result = rb_funcall(result, rb_intern("-@"), 0);
202 }
203
204 if (!SPECIAL_CONST_P(result)) {
205 RB_OBJ_SET_SHAREABLE(result); // bignum
206 }
207
208 return result;
209}
210
214static inline VALUE
215parse_integer(const pm_integer_node_t *node)
216{
217 return parse_integer_value(&node->value);
218}
219
223static VALUE
224parse_float(const pm_float_node_t *node)
225{
226 VALUE val = DBL2NUM(node->value);
227 if (!FLONUM_P(val)) {
228 RB_OBJ_SET_SHAREABLE(val);
229 }
230 return val;
231}
232
239static VALUE
240parse_rational(const pm_rational_node_t *node)
241{
242 VALUE numerator = parse_integer_value(&node->numerator);
243 VALUE denominator = parse_integer_value(&node->denominator);
244
245 return rb_ractor_make_shareable(rb_rational_new(numerator, denominator));
246}
247
254static VALUE
255parse_imaginary(const pm_imaginary_node_t *node)
256{
257 VALUE imaginary_part;
258 switch (PM_NODE_TYPE(node->numeric)) {
259 case PM_FLOAT_NODE: {
260 imaginary_part = parse_float((const pm_float_node_t *) node->numeric);
261 break;
262 }
263 case PM_INTEGER_NODE: {
264 imaginary_part = parse_integer((const pm_integer_node_t *) node->numeric);
265 break;
266 }
267 case PM_RATIONAL_NODE: {
268 imaginary_part = parse_rational((const pm_rational_node_t *) node->numeric);
269 break;
270 }
271 default:
272 rb_bug("Unexpected numeric type on imaginary number %s\n", pm_node_type_to_str(PM_NODE_TYPE(node->numeric)));
273 }
274
275 return RB_OBJ_SET_SHAREABLE(rb_complex_raw(INT2FIX(0), imaginary_part));
276}
277
278static inline VALUE
279parse_string(const pm_scope_node_t *scope_node, const pm_string_t *string)
280{
281 return rb_enc_str_new((const char *) pm_string_source(string), pm_string_length(string), scope_node->encoding);
282}
283
289static inline VALUE
290parse_string_encoded(const pm_node_t *node, const pm_string_t *string, rb_encoding *default_encoding)
291{
292 rb_encoding *encoding;
293
294 if (node->flags & PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING) {
295 encoding = rb_ascii8bit_encoding();
296 }
297 else if (node->flags & PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING) {
298 encoding = rb_utf8_encoding();
299 }
300 else {
301 encoding = default_encoding;
302 }
303
304 return rb_enc_str_new((const char *) pm_string_source(string), pm_string_length(string), encoding);
305}
306
307static inline VALUE
308parse_static_literal_string(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_string_t *string)
309{
310 rb_encoding *encoding;
311
312 if (node->flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
313 encoding = rb_ascii8bit_encoding();
314 }
315 else if (node->flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
316 encoding = rb_utf8_encoding();
317 }
318 else {
319 encoding = scope_node->encoding;
320 }
321
322 VALUE value = rb_enc_literal_str((const char *) pm_string_source(string), pm_string_length(string), encoding);
323 rb_enc_str_coderange(value);
324
325 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
326 int line_number = pm_node_line_number(scope_node->parser, node);
327 value = rb_ractor_make_shareable(rb_str_with_debug_created_info(value, rb_iseq_path(iseq), line_number));
328 }
329
330 return value;
331}
332
333static inline ID
334parse_string_symbol(const pm_scope_node_t *scope_node, const pm_symbol_node_t *symbol)
335{
336 rb_encoding *encoding;
337 if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING) {
338 encoding = rb_utf8_encoding();
339 }
340 else if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING) {
341 encoding = rb_ascii8bit_encoding();
342 }
343 else if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING) {
344 encoding = rb_usascii_encoding();
345 }
346 else {
347 encoding = scope_node->encoding;
348 }
349
350 return rb_intern3((const char *) pm_string_source(&symbol->unescaped), pm_string_length(&symbol->unescaped), encoding);
351}
352
353static int
354pm_optimizable_range_item_p(const pm_node_t *node)
355{
356 return (!node || PM_NODE_TYPE_P(node, PM_INTEGER_NODE) || PM_NODE_TYPE_P(node, PM_NIL_NODE));
357}
358
360static VALUE
361parse_regexp_error(rb_iseq_t *iseq, int32_t line_number, const char *fmt, ...)
362{
363 va_list args;
364 va_start(args, fmt);
365 VALUE error = rb_syntax_error_append(Qnil, rb_iseq_path(iseq), line_number, -1, NULL, "%" PRIsVALUE, args);
366 va_end(args);
367 rb_exc_raise(error);
368}
369
370static VALUE
371parse_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)
372{
373 // If we were passed an explicit regexp encoding, then we need to double
374 // check that it's okay here for this fragment of the string.
375 rb_encoding *encoding;
376
377 if (explicit_regexp_encoding != NULL) {
378 encoding = explicit_regexp_encoding;
379 }
380 else if (node->flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
381 encoding = rb_ascii8bit_encoding();
382 }
383 else if (node->flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
384 encoding = rb_utf8_encoding();
385 }
386 else {
387 encoding = implicit_regexp_encoding;
388 }
389
390 VALUE string = rb_enc_str_new((const char *) pm_string_source(unescaped), pm_string_length(unescaped), encoding);
391 VALUE error = rb_reg_check_preprocess(string);
392
393 if (error != Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, node), "%" PRIsVALUE, rb_obj_as_string(error));
394 return string;
395}
396
397static VALUE
398pm_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)
399{
400 VALUE current = Qnil;
401
402 for (size_t index = 0; index < nodes->size; index++) {
403 const pm_node_t *part = nodes->nodes[index];
404 VALUE string;
405
406 switch (PM_NODE_TYPE(part)) {
407 case PM_STRING_NODE:
408 if (implicit_regexp_encoding != NULL) {
409 if (top) {
410 string = parse_regexp_string_part(iseq, scope_node, part, &((const pm_string_node_t *) part)->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
411 }
412 else {
413 string = parse_string_encoded(part, &((const pm_string_node_t *) part)->unescaped, scope_node->encoding);
414 VALUE error = rb_reg_check_preprocess(string);
415 if (error != Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, part), "%" PRIsVALUE, rb_obj_as_string(error));
416 }
417 }
418 else {
419 string = parse_string_encoded(part, &((const pm_string_node_t *) part)->unescaped, scope_node->encoding);
420 }
421 break;
422 case PM_INTERPOLATED_STRING_NODE:
423 string = pm_static_literal_concat(iseq, &((const pm_interpolated_string_node_t *) part)->parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
424 break;
425 case PM_EMBEDDED_STATEMENTS_NODE: {
426 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) part;
427 string = pm_static_literal_concat(iseq, &cast->statements->body, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
428 break;
429 }
430 default:
431 RUBY_ASSERT(false && "unexpected node type in pm_static_literal_concat");
432 return Qnil;
433 }
434
435 if (current != Qnil) {
436 current = rb_str_concat(current, string);
437 }
438 else {
439 current = string;
440 }
441 }
442
443 return top ? rb_fstring(current) : current;
444}
445
446#define RE_OPTION_ENCODING_SHIFT 8
447#define RE_OPTION_ENCODING(encoding) (((encoding) & 0xFF) << RE_OPTION_ENCODING_SHIFT)
448#define ARG_ENCODING_NONE 32
449#define ARG_ENCODING_FIXED 16
450#define ENC_ASCII8BIT 1
451#define ENC_EUC_JP 2
452#define ENC_Windows_31J 3
453#define ENC_UTF8 4
454
459static int
460parse_regexp_flags(const pm_node_t *node)
461{
462 int flags = 0;
463
464 // Check "no encoding" first so that flags don't get clobbered
465 // We're calling `rb_char_to_option_kcode` in this case so that
466 // we don't need to have access to `ARG_ENCODING_NONE`
467 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
468 flags |= ARG_ENCODING_NONE;
469 }
470
471 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
472 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_EUC_JP));
473 }
474
475 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
476 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_Windows_31J));
477 }
478
479 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
480 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_UTF8));
481 }
482
483 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
484 flags |= ONIG_OPTION_IGNORECASE;
485 }
486
487 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
488 flags |= ONIG_OPTION_MULTILINE;
489 }
490
491 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
492 flags |= ONIG_OPTION_EXTEND;
493 }
494
495 return flags;
496}
497
498#undef RE_OPTION_ENCODING_SHIFT
499#undef RE_OPTION_ENCODING
500#undef ARG_ENCODING_FIXED
501#undef ARG_ENCODING_NONE
502#undef ENC_ASCII8BIT
503#undef ENC_EUC_JP
504#undef ENC_Windows_31J
505#undef ENC_UTF8
506
507static rb_encoding *
508parse_regexp_encoding(const pm_scope_node_t *scope_node, const pm_node_t *node)
509{
510 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) || PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
511 return rb_ascii8bit_encoding();
512 }
513 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
514 return rb_utf8_encoding();
515 }
516 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
517 return rb_enc_get_from_index(ENCINDEX_EUC_JP);
518 }
519 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
520 return rb_enc_get_from_index(ENCINDEX_Windows_31J);
521 }
522 else {
523 return NULL;
524 }
525}
526
527static VALUE
528parse_regexp(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, VALUE string)
529{
530 VALUE errinfo = rb_errinfo();
531
532 int32_t line_number = pm_node_line_number(scope_node->parser, node);
533 VALUE regexp = rb_reg_compile(string, parse_regexp_flags(node), (const char *) pm_string_source(&scope_node->parser->filepath), line_number);
534
535 if (NIL_P(regexp)) {
536 VALUE message = rb_attr_get(rb_errinfo(), idMesg);
537 rb_set_errinfo(errinfo);
538
539 parse_regexp_error(iseq, line_number, "%" PRIsVALUE, message);
540 return Qnil;
541 }
542
543 return RB_OBJ_SET_SHAREABLE(rb_obj_freeze(regexp));
544}
545
546static inline VALUE
547parse_regexp_literal(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_string_t *unescaped)
548{
549 rb_encoding *regexp_encoding = parse_regexp_encoding(scope_node, node);
550 if (regexp_encoding == NULL) regexp_encoding = scope_node->encoding;
551
552 VALUE string = rb_enc_str_new((const char *) pm_string_source(unescaped), pm_string_length(unescaped), regexp_encoding);
553 RB_OBJ_SET_SHAREABLE(string);
554 return parse_regexp(iseq, scope_node, node, string);
555}
556
557static inline VALUE
558parse_regexp_concat(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_node_list_t *parts)
559{
560 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
561 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
562
563 VALUE string = pm_static_literal_concat(iseq, parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
564 return parse_regexp(iseq, scope_node, node, string);
565}
566
567static 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);
568
569static int
570pm_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, bool mutable_result, bool frozen_result)
571{
572 int stack_size = 0;
573 size_t parts_size = parts->size;
574 bool interpolated = false;
575
576 if (parts_size > 0) {
577 VALUE current_string = Qnil;
578 pm_node_location_t current_location = *node_location;
579
580 for (size_t index = 0; index < parts_size; index++) {
581 const pm_node_t *part = parts->nodes[index];
582
583 if (PM_NODE_TYPE_P(part, PM_STRING_NODE)) {
584 const pm_string_node_t *string_node = (const pm_string_node_t *) part;
585 VALUE string_value;
586
587 if (implicit_regexp_encoding == NULL) {
588 string_value = parse_string_encoded(part, &string_node->unescaped, scope_node->encoding);
589 }
590 else {
591 string_value = parse_regexp_string_part(iseq, scope_node, (const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
592 }
593
594 if (RTEST(current_string)) {
595 current_string = rb_str_concat(current_string, string_value);
596 }
597 else {
598 current_string = string_value;
599 if (index != 0) current_location = PM_NODE_END_LOCATION(scope_node->parser, part);
600 }
601 }
602 else {
603 interpolated = true;
604
605 if (
606 PM_NODE_TYPE_P(part, PM_EMBEDDED_STATEMENTS_NODE) &&
607 ((const pm_embedded_statements_node_t *) part)->statements != NULL &&
608 ((const pm_embedded_statements_node_t *) part)->statements->body.size == 1 &&
609 PM_NODE_TYPE_P(((const pm_embedded_statements_node_t *) part)->statements->body.nodes[0], PM_STRING_NODE)
610 ) {
611 const pm_string_node_t *string_node = (const pm_string_node_t *) ((const pm_embedded_statements_node_t *) part)->statements->body.nodes[0];
612 VALUE string_value;
613
614 if (implicit_regexp_encoding == NULL) {
615 string_value = parse_string_encoded(part, &string_node->unescaped, scope_node->encoding);
616 }
617 else {
618 string_value = parse_regexp_string_part(iseq, scope_node, (const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
619 }
620
621 if (RTEST(current_string)) {
622 current_string = rb_str_concat(current_string, string_value);
623 }
624 else {
625 current_string = string_value;
626 current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
627 }
628 }
629 else {
630 if (!RTEST(current_string)) {
631 rb_encoding *encoding;
632
633 if (implicit_regexp_encoding != NULL) {
634 if (explicit_regexp_encoding != NULL) {
635 encoding = explicit_regexp_encoding;
636 }
637 else if (scope_node->parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
638 encoding = rb_ascii8bit_encoding();
639 }
640 else {
641 encoding = implicit_regexp_encoding;
642 }
643 }
644 else {
645 encoding = scope_node->encoding;
646 }
647
648 if (parts_size == 1) {
649 current_string = rb_enc_str_new(NULL, 0, encoding);
650 }
651 }
652
653 if (RTEST(current_string)) {
654 VALUE operand = rb_fstring(current_string);
655 PUSH_INSN1(ret, current_location, putobject, operand);
656 stack_size++;
657 }
658
659 PM_COMPILE_NOT_POPPED(part);
660
661 const pm_node_location_t current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
662 PUSH_INSN(ret, current_location, dup);
663
664 {
665 const struct rb_callinfo *callinfo = new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE, NULL, FALSE);
666 PUSH_INSN1(ret, current_location, objtostring, callinfo);
667 }
668
669 PUSH_INSN(ret, current_location, anytostring);
670
671 current_string = Qnil;
672 stack_size++;
673 }
674 }
675 }
676
677 if (RTEST(current_string)) {
678 current_string = rb_fstring(current_string);
679
680 if (stack_size == 0) {
681 if (frozen_result) {
682 PUSH_INSN1(ret, current_location, putobject, current_string);
683 } else if (mutable_result || interpolated) {
684 PUSH_INSN1(ret, current_location, putstring, current_string);
685 } else {
686 PUSH_INSN1(ret, current_location, putchilledstring, current_string);
687 }
688 } else {
689 PUSH_INSN1(ret, current_location, putobject, current_string);
690 }
691
692 current_string = Qnil;
693 stack_size++;
694 }
695 }
696 else {
697 PUSH_INSN(ret, *node_location, putnil);
698 }
699
700 return stack_size;
701}
702
703static void
704pm_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)
705{
706 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
707 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
708
709 int length = pm_interpolated_node_compile(iseq, parts, node_location, ret, popped, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false, false);
710 PUSH_INSN2(ret, *node_location, toregexp, INT2FIX(parse_regexp_flags(node) & 0xFF), INT2FIX(length));
711}
712
713static VALUE
714pm_source_file_value(const pm_source_file_node_t *node, const pm_scope_node_t *scope_node)
715{
716 const pm_string_t *filepath = &node->filepath;
717 size_t length = pm_string_length(filepath);
718
719 if (length > 0) {
720 rb_encoding *filepath_encoding = scope_node->filepath_encoding != NULL ? scope_node->filepath_encoding : rb_utf8_encoding();
721 return rb_enc_interned_str((const char *) pm_string_source(filepath), length, filepath_encoding);
722 }
723 else {
724 return rb_fstring_lit("<compiled>");
725 }
726}
727
732static VALUE
733pm_static_literal_string(rb_iseq_t *iseq, VALUE string, int line_number)
734{
735 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
736 VALUE str = rb_str_with_debug_created_info(string, rb_iseq_path(iseq), line_number);
737 RB_OBJ_SET_SHAREABLE(str);
738 return str;
739 }
740 else {
741 return rb_fstring(string);
742 }
743}
744
750static VALUE
751pm_static_literal_value(rb_iseq_t *iseq, const pm_node_t *node, const pm_scope_node_t *scope_node)
752{
753 // Every node that comes into this function should already be marked as
754 // static literal. If it's not, then we have a bug somewhere.
755 RUBY_ASSERT(PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL));
756
757 switch (PM_NODE_TYPE(node)) {
758 case PM_ARRAY_NODE: {
759 const pm_array_node_t *cast = (const pm_array_node_t *) node;
760 const pm_node_list_t *elements = &cast->elements;
761
762 VALUE value = rb_ary_hidden_new(elements->size);
763 for (size_t index = 0; index < elements->size; index++) {
764 rb_ary_push(value, pm_static_literal_value(iseq, elements->nodes[index], scope_node));
765 }
766
767 RB_OBJ_SET_FROZEN_SHAREABLE(value);
768 return value;
769 }
770 case PM_FALSE_NODE:
771 return Qfalse;
772 case PM_FLOAT_NODE:
773 return parse_float((const pm_float_node_t *) node);
774 case PM_HASH_NODE: {
775 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
776 const pm_node_list_t *elements = &cast->elements;
777
778 VALUE array = rb_ary_hidden_new(elements->size * 2);
779 for (size_t index = 0; index < elements->size; index++) {
780 RUBY_ASSERT(PM_NODE_TYPE_P(elements->nodes[index], PM_ASSOC_NODE));
781 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) elements->nodes[index];
782 VALUE pair[2] = { pm_static_literal_value(iseq, cast->key, scope_node), pm_static_literal_value(iseq, cast->value, scope_node) };
783 rb_ary_cat(array, pair, 2);
784 }
785
786 VALUE value = rb_hash_new_with_size(elements->size);
787 rb_hash_bulk_insert(RARRAY_LEN(array), RARRAY_CONST_PTR(array), value);
788
789 value = rb_obj_hide(value);
790 RB_OBJ_SET_FROZEN_SHAREABLE(value);
791 return value;
792 }
793 case PM_IMAGINARY_NODE:
794 return parse_imaginary((const pm_imaginary_node_t *) node);
795 case PM_INTEGER_NODE:
796 return parse_integer((const pm_integer_node_t *) node);
797 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
798 const pm_interpolated_match_last_line_node_t *cast = (const pm_interpolated_match_last_line_node_t *) node;
799 return parse_regexp_concat(iseq, scope_node, (const pm_node_t *) cast, &cast->parts);
800 }
801 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
802 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
803 return parse_regexp_concat(iseq, scope_node, (const pm_node_t *) cast, &cast->parts);
804 }
805 case PM_INTERPOLATED_STRING_NODE: {
806 VALUE string = pm_static_literal_concat(iseq, &((const pm_interpolated_string_node_t *) node)->parts, scope_node, NULL, NULL, false);
807 int line_number = pm_node_line_number(scope_node->parser, node);
808 return pm_static_literal_string(iseq, string, line_number);
809 }
810 case PM_INTERPOLATED_SYMBOL_NODE: {
811 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
812 VALUE string = pm_static_literal_concat(iseq, &cast->parts, scope_node, NULL, NULL, true);
813
814 return ID2SYM(rb_intern_str(string));
815 }
816 case PM_MATCH_LAST_LINE_NODE: {
817 const pm_match_last_line_node_t *cast = (const pm_match_last_line_node_t *) node;
818 return parse_regexp_literal(iseq, scope_node, (const pm_node_t *) cast, &cast->unescaped);
819 }
820 case PM_NIL_NODE:
821 return Qnil;
822 case PM_RATIONAL_NODE:
823 return parse_rational((const pm_rational_node_t *) node);
824 case PM_REGULAR_EXPRESSION_NODE: {
825 const pm_regular_expression_node_t *cast = (const pm_regular_expression_node_t *) node;
826 return parse_regexp_literal(iseq, scope_node, (const pm_node_t *) cast, &cast->unescaped);
827 }
828 case PM_SOURCE_ENCODING_NODE:
829 return rb_enc_from_encoding(scope_node->encoding);
830 case PM_SOURCE_FILE_NODE: {
831 const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
832 return pm_source_file_value(cast, scope_node);
833 }
834 case PM_SOURCE_LINE_NODE:
835 return INT2FIX(pm_node_line_number(scope_node->parser, node));
836 case PM_STRING_NODE: {
837 const pm_string_node_t *cast = (const pm_string_node_t *) node;
838 return parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
839 }
840 case PM_SYMBOL_NODE:
841 return ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) node));
842 case PM_TRUE_NODE:
843 return Qtrue;
844 default:
845 rb_bug("Don't have a literal value for node type %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
846 return Qfalse;
847 }
848}
849
853static rb_code_location_t
854pm_code_location(const pm_scope_node_t *scope_node, const pm_node_t *node)
855{
856 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, node);
857 const pm_line_column_t end_location = PM_NODE_END_LINE_COLUMN(scope_node->parser, node);
858
859 return (rb_code_location_t) {
860 .beg_pos = { .lineno = start_location.line, .column = start_location.column },
861 .end_pos = { .lineno = end_location.line, .column = end_location.column }
862 };
863}
864
870#define PM_BRANCH_COVERAGE_P(iseq) (ISEQ_COVERAGE(iseq) && ISEQ_BRANCH_COVERAGE(iseq))
871
872static void
873pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond,
874 LABEL *then_label, LABEL *else_label, pm_scope_node_t *scope_node);
875
876static void
877pm_compile_logical(rb_iseq_t *iseq, LINK_ANCHOR *const ret, pm_node_t *cond, LABEL *then_label, LABEL *else_label, pm_scope_node_t *scope_node)
878{
879 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, cond);
880
881 DECL_ANCHOR(seq);
882
883 LABEL *label = NEW_LABEL(location.line);
884 if (!then_label) then_label = label;
885 else if (!else_label) else_label = label;
886
887 pm_compile_branch_condition(iseq, seq, cond, then_label, else_label, scope_node);
888
889 if (LIST_INSN_SIZE_ONE(seq)) {
890 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(seq));
891 if (insn->insn_id == BIN(jump) && (LABEL *)(insn->operands[0]) == label) return;
892 }
893
894 if (label->refcnt) {
895 PUSH_LABEL(seq, label);
896 }
897
898 PUSH_SEQ(ret, seq);
899 return;
900}
901
902static void
903pm_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)
904{
905 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
906
907 if (PM_NODE_TYPE_P(node, PM_INTEGER_NODE)) {
908 PM_COMPILE_NOT_POPPED(node);
909
910 VALUE operand = ID2SYM(rb_intern("$."));
911 PUSH_INSN1(ret, location, getglobal, operand);
912
913 PUSH_SEND(ret, location, idEq, INT2FIX(1));
914 if (popped) PUSH_INSN(ret, location, pop);
915 }
916 else {
917 PM_COMPILE(node);
918 }
919}
920
921static void
922pm_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)
923{
924 const pm_node_location_t location = { .line = lineno, .node_id = -1 };
925 LABEL *lend = NEW_LABEL(location.line);
926
927 int again = !(flip_flop_node->base.flags & PM_RANGE_FLAGS_EXCLUDE_END);
928
929 rb_num_t count = ISEQ_FLIP_CNT_INCREMENT(ISEQ_BODY(iseq)->local_iseq) + VM_SVAR_FLIPFLOP_START;
930 VALUE key = INT2FIX(count);
931
932 PUSH_INSN2(ret, location, getspecial, key, INT2FIX(0));
933 PUSH_INSNL(ret, location, branchif, lend);
934
935 if (flip_flop_node->left) {
936 pm_compile_flip_flop_bound(iseq, flip_flop_node->left, ret, popped, scope_node);
937 }
938 else {
939 PUSH_INSN(ret, location, putnil);
940 }
941
942 PUSH_INSNL(ret, location, branchunless, else_label);
943 PUSH_INSN1(ret, location, putobject, Qtrue);
944 PUSH_INSN1(ret, location, setspecial, key);
945 if (!again) {
946 PUSH_INSNL(ret, location, jump, then_label);
947 }
948
949 PUSH_LABEL(ret, lend);
950 if (flip_flop_node->right) {
951 pm_compile_flip_flop_bound(iseq, flip_flop_node->right, ret, popped, scope_node);
952 }
953 else {
954 PUSH_INSN(ret, location, putnil);
955 }
956
957 PUSH_INSNL(ret, location, branchunless, then_label);
958 PUSH_INSN1(ret, location, putobject, Qfalse);
959 PUSH_INSN1(ret, location, setspecial, key);
960 PUSH_INSNL(ret, location, jump, then_label);
961}
962
963static 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);
964
965static void
966pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond, LABEL *then_label, LABEL *else_label, pm_scope_node_t *scope_node)
967{
968 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, cond);
969
970again:
971 switch (PM_NODE_TYPE(cond)) {
972 case PM_AND_NODE: {
973 const pm_and_node_t *cast = (const pm_and_node_t *) cond;
974 pm_compile_logical(iseq, ret, cast->left, NULL, else_label, scope_node);
975
976 cond = cast->right;
977 goto again;
978 }
979 case PM_OR_NODE: {
980 const pm_or_node_t *cast = (const pm_or_node_t *) cond;
981 pm_compile_logical(iseq, ret, cast->left, then_label, NULL, scope_node);
982
983 cond = cast->right;
984 goto again;
985 }
986 case PM_FALSE_NODE:
987 case PM_NIL_NODE:
988 PUSH_INSNL(ret, location, jump, else_label);
989 return;
990 case PM_FLOAT_NODE:
991 case PM_IMAGINARY_NODE:
992 case PM_INTEGER_NODE:
993 case PM_LAMBDA_NODE:
994 case PM_RATIONAL_NODE:
995 case PM_REGULAR_EXPRESSION_NODE:
996 case PM_STRING_NODE:
997 case PM_SYMBOL_NODE:
998 case PM_TRUE_NODE:
999 PUSH_INSNL(ret, location, jump, then_label);
1000 return;
1001 case PM_FLIP_FLOP_NODE:
1002 pm_compile_flip_flop((const pm_flip_flop_node_t *) cond, else_label, then_label, iseq, location.line, ret, false, scope_node);
1003 return;
1004 case PM_DEFINED_NODE: {
1005 const pm_defined_node_t *cast = (const pm_defined_node_t *) cond;
1006 pm_compile_defined_expr(iseq, cast->value, &location, ret, false, scope_node, true);
1007 break;
1008 }
1009 default: {
1010 DECL_ANCHOR(cond_seq);
1011 pm_compile_node(iseq, cond, cond_seq, false, scope_node);
1012
1013 if (LIST_INSN_SIZE_ONE(cond_seq)) {
1014 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(cond_seq));
1015
1016 if (insn->insn_id == BIN(putobject)) {
1017 if (RTEST(insn->operands[0])) {
1018 PUSH_INSNL(ret, location, jump, then_label);
1019 // maybe unreachable
1020 return;
1021 }
1022 else {
1023 PUSH_INSNL(ret, location, jump, else_label);
1024 return;
1025 }
1026 }
1027 }
1028
1029 PUSH_SEQ(ret, cond_seq);
1030 break;
1031 }
1032 }
1033
1034 PUSH_INSNL(ret, location, branchunless, else_label);
1035 PUSH_INSNL(ret, location, jump, then_label);
1036}
1037
1041static void
1042pm_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)
1043{
1044 const pm_node_location_t location = *node_location;
1045 LABEL *then_label = NEW_LABEL(location.line);
1046 LABEL *else_label = NEW_LABEL(location.line);
1047 LABEL *end_label = NULL;
1048
1049 DECL_ANCHOR(cond_seq);
1050 pm_compile_branch_condition(iseq, cond_seq, predicate, then_label, else_label, scope_node);
1051 PUSH_SEQ(ret, cond_seq);
1052
1053 rb_code_location_t conditional_location = { 0 };
1054 VALUE branches = Qfalse;
1055
1056 if (then_label->refcnt && else_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1057 conditional_location = pm_code_location(scope_node, node);
1058 branches = decl_branch_base(iseq, PTR2NUM(node), &conditional_location, type == PM_IF_NODE ? "if" : "unless");
1059 }
1060
1061 if (then_label->refcnt) {
1062 PUSH_LABEL(ret, then_label);
1063
1064 DECL_ANCHOR(then_seq);
1065
1066 if (statements != NULL) {
1067 pm_compile_node(iseq, (const pm_node_t *) statements, then_seq, popped, scope_node);
1068 }
1069 else if (!popped) {
1070 PUSH_SYNTHETIC_PUTNIL(then_seq, iseq);
1071 }
1072
1073 if (else_label->refcnt) {
1074 // Establish branch coverage for the then block.
1075 if (PM_BRANCH_COVERAGE_P(iseq)) {
1076 rb_code_location_t branch_location;
1077
1078 if (statements != NULL) {
1079 branch_location = pm_code_location(scope_node, (const pm_node_t *) statements);
1080 } else if (type == PM_IF_NODE) {
1081 pm_line_column_t predicate_end = PM_NODE_END_LINE_COLUMN(scope_node->parser, predicate);
1082 branch_location = (rb_code_location_t) {
1083 .beg_pos = { .lineno = predicate_end.line, .column = predicate_end.column },
1084 .end_pos = { .lineno = predicate_end.line, .column = predicate_end.column }
1085 };
1086 } else {
1087 branch_location = conditional_location;
1088 }
1089
1090 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0, type == PM_IF_NODE ? "then" : "else", branches);
1091 }
1092
1093 end_label = NEW_LABEL(location.line);
1094 PUSH_INSNL(then_seq, location, jump, end_label);
1095 if (!popped) PUSH_INSN(then_seq, location, pop);
1096 }
1097
1098 PUSH_SEQ(ret, then_seq);
1099 }
1100
1101 if (else_label->refcnt) {
1102 PUSH_LABEL(ret, else_label);
1103
1104 DECL_ANCHOR(else_seq);
1105
1106 if (subsequent != NULL) {
1107 pm_compile_node(iseq, subsequent, else_seq, popped, scope_node);
1108 }
1109 else if (!popped) {
1110 PUSH_SYNTHETIC_PUTNIL(else_seq, iseq);
1111 }
1112
1113 // Establish branch coverage for the else block.
1114 if (then_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1115 rb_code_location_t branch_location;
1116
1117 if (subsequent == NULL) {
1118 branch_location = conditional_location;
1119 } else if (PM_NODE_TYPE_P(subsequent, PM_ELSE_NODE)) {
1120 const pm_else_node_t *else_node = (const pm_else_node_t *) subsequent;
1121 branch_location = pm_code_location(scope_node, else_node->statements != NULL ? ((const pm_node_t *) else_node->statements) : (const pm_node_t *) else_node);
1122 } else {
1123 branch_location = pm_code_location(scope_node, (const pm_node_t *) subsequent);
1124 }
1125
1126 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 1, type == PM_IF_NODE ? "else" : "then", branches);
1127 }
1128
1129 PUSH_SEQ(ret, else_seq);
1130 }
1131
1132 if (end_label) {
1133 PUSH_LABEL(ret, end_label);
1134 }
1135
1136 return;
1137}
1138
1142static void
1143pm_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)
1144{
1145 const pm_node_location_t location = *node_location;
1146
1147 LABEL *prev_start_label = ISEQ_COMPILE_DATA(iseq)->start_label;
1148 LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label;
1149 LABEL *prev_redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label;
1150
1151 LABEL *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(location.line); /* next */
1152 LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(location.line); /* redo */
1153 LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(location.line); /* break */
1154 LABEL *end_label = NEW_LABEL(location.line);
1155 LABEL *adjust_label = NEW_LABEL(location.line);
1156
1157 LABEL *next_catch_label = NEW_LABEL(location.line);
1158 LABEL *tmp_label = NULL;
1159
1160 // We're pushing onto the ensure stack because breaks need to break out of
1161 // this loop and not break into the ensure statements within the same
1162 // lexical scope.
1163 struct iseq_compile_data_ensure_node_stack enl;
1164 push_ensure_entry(iseq, &enl, NULL, NULL);
1165
1166 // begin; end while true
1167 if (flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
1168 tmp_label = NEW_LABEL(location.line);
1169 PUSH_INSNL(ret, location, jump, tmp_label);
1170 }
1171 else {
1172 // while true; end
1173 PUSH_INSNL(ret, location, jump, next_label);
1174 }
1175
1176 PUSH_LABEL(ret, adjust_label);
1177 PUSH_INSN(ret, location, putnil);
1178 PUSH_LABEL(ret, next_catch_label);
1179 PUSH_INSN(ret, location, pop);
1180 PUSH_INSNL(ret, location, jump, next_label);
1181 if (tmp_label) PUSH_LABEL(ret, tmp_label);
1182
1183 PUSH_LABEL(ret, redo_label);
1184
1185 // Establish branch coverage for the loop.
1186 if (PM_BRANCH_COVERAGE_P(iseq)) {
1187 rb_code_location_t loop_location = pm_code_location(scope_node, node);
1188 VALUE branches = decl_branch_base(iseq, PTR2NUM(node), &loop_location, type == PM_WHILE_NODE ? "while" : "until");
1189
1190 rb_code_location_t branch_location = statements != NULL ? pm_code_location(scope_node, (const pm_node_t *) statements) : loop_location;
1191 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0, "body", branches);
1192 }
1193
1194 if (statements != NULL) PM_COMPILE_POPPED((const pm_node_t *) statements);
1195 PUSH_LABEL(ret, next_label);
1196
1197 if (type == PM_WHILE_NODE) {
1198 pm_compile_branch_condition(iseq, ret, predicate, redo_label, end_label, scope_node);
1199 }
1200 else if (type == PM_UNTIL_NODE) {
1201 pm_compile_branch_condition(iseq, ret, predicate, end_label, redo_label, scope_node);
1202 }
1203
1204 PUSH_LABEL(ret, end_label);
1205 PUSH_ADJUST_RESTORE(ret, adjust_label);
1206 PUSH_INSN(ret, location, putnil);
1207
1208 PUSH_LABEL(ret, break_label);
1209 if (popped) PUSH_INSN(ret, location, pop);
1210
1211 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label, NULL, break_label);
1212 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, NULL, next_catch_label);
1213 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, NULL, ISEQ_COMPILE_DATA(iseq)->redo_label);
1214
1215 ISEQ_COMPILE_DATA(iseq)->start_label = prev_start_label;
1216 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label;
1217 ISEQ_COMPILE_DATA(iseq)->redo_label = prev_redo_label;
1218 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->prev;
1219
1220 return;
1221}
1222
1223// This recurses through scopes and finds the local index at any scope level
1224// It also takes a pointer to depth, and increments depth appropriately
1225// according to the depth of the local.
1226static pm_local_index_t
1227pm_lookup_local_index(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, pm_constant_id_t constant_id, int start_depth)
1228{
1229 pm_local_index_t lindex = { 0 };
1230 st_data_t local_index;
1231
1232 int level;
1233 for (level = 0; level < start_depth; level++) {
1234 scope_node = scope_node->previous;
1235 }
1236
1237 while (!st_lookup(scope_node->index_lookup_table, constant_id, &local_index)) {
1238 level++;
1239
1240 if (scope_node->previous) {
1241 scope_node = scope_node->previous;
1242 }
1243 else {
1244 // We have recursed up all scope nodes
1245 // and have not found the local yet
1246 rb_bug("Local with constant_id %u does not exist", (unsigned int) constant_id);
1247 }
1248 }
1249
1250 lindex.level = level;
1251 lindex.index = scope_node->local_table_for_iseq_size - (int) local_index;
1252 return lindex;
1253}
1254
1255// This returns the CRuby ID which maps to the pm_constant_id_t
1256//
1257// Constant_ids in prism are indexes of the constants in prism's constant pool.
1258// We add a constants mapping on the scope_node which is a mapping from
1259// these constant_id indexes to the CRuby IDs that they represent.
1260// This helper method allows easy access to those IDs
1261static ID
1262pm_constant_id_lookup(const pm_scope_node_t *scope_node, pm_constant_id_t constant_id)
1263{
1264 if (constant_id < 1 || constant_id > scope_node->parser->constant_pool.size) {
1265 rb_bug("constant_id out of range: %u", (unsigned int)constant_id);
1266 }
1267 return scope_node->constants[constant_id - 1];
1268}
1269
1270static rb_iseq_t *
1271pm_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)
1272{
1273 debugs("[new_child_iseq]> ---------------------------------------\n");
1274 int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth;
1275 int error_state;
1276 rb_iseq_t *ret_iseq = pm_iseq_new_with_opt(node, name,
1277 rb_iseq_path(iseq), rb_iseq_realpath(iseq),
1278 line_no, parent,
1279 isolated_depth ? isolated_depth + 1 : 0,
1280 type, ISEQ_COMPILE_DATA(iseq)->option, &error_state);
1281
1282 if (error_state) {
1283 pm_scope_node_destroy(node);
1284 RUBY_ASSERT(ret_iseq == NULL);
1285 rb_jump_tag(error_state);
1286 }
1287 debugs("[new_child_iseq]< ---------------------------------------\n");
1288 return ret_iseq;
1289}
1290
1291static int
1292pm_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)
1293{
1294 if (PM_NODE_TYPE_P(node, PM_CONSTANT_PATH_NODE)) {
1295 const pm_node_t *parent = ((const pm_constant_path_node_t *) node)->parent;
1296
1297 if (parent) {
1298 /* Bar::Foo */
1299 PM_COMPILE(parent);
1300 return VM_DEFINECLASS_FLAG_SCOPED;
1301 }
1302 else {
1303 /* toplevel class ::Foo */
1304 PUSH_INSN1(ret, *node_location, putobject, rb_cObject);
1305 return VM_DEFINECLASS_FLAG_SCOPED;
1306 }
1307 }
1308 else {
1309 /* class at cbase Foo */
1310 PUSH_INSN1(ret, *node_location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
1311 return 0;
1312 }
1313}
1314
1319static void
1320pm_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)
1321{
1322 const pm_node_location_t location = *node_location;
1323 LABEL *lfin = NEW_LABEL(location.line);
1324 LABEL *lcfin = NEW_LABEL(location.line);
1325 LABEL *lskip = NULL;
1326
1327 int flag = PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
1328 ID id_read_name = pm_constant_id_lookup(scope_node, read_name);
1329
1330 PM_COMPILE_NOT_POPPED(receiver);
1331 if (safe_nav) {
1332 lskip = NEW_LABEL(location.line);
1333 PUSH_INSN(ret, location, dup);
1334 PUSH_INSNL(ret, location, branchnil, lskip);
1335 }
1336
1337 PUSH_INSN(ret, location, dup);
1338 PUSH_SEND_WITH_FLAG(ret, location, id_read_name, INT2FIX(0), INT2FIX(flag));
1339 if (!popped) PUSH_INSN(ret, location, dup);
1340
1341 if (and_node) {
1342 PUSH_INSNL(ret, location, branchunless, lcfin);
1343 }
1344 else {
1345 PUSH_INSNL(ret, location, branchif, lcfin);
1346 }
1347
1348 if (!popped) PUSH_INSN(ret, location, pop);
1349 PM_COMPILE_NOT_POPPED(value);
1350
1351 if (!popped) {
1352 PUSH_INSN(ret, location, swap);
1353 PUSH_INSN1(ret, location, topn, INT2FIX(1));
1354 }
1355
1356 ID id_write_name = pm_constant_id_lookup(scope_node, write_name);
1357 PUSH_SEND_WITH_FLAG(ret, location, id_write_name, INT2FIX(1), INT2FIX(flag));
1358 PUSH_INSNL(ret, location, jump, lfin);
1359
1360 PUSH_LABEL(ret, lcfin);
1361 if (!popped) PUSH_INSN(ret, location, swap);
1362
1363 PUSH_LABEL(ret, lfin);
1364
1365 if (lskip && popped) PUSH_LABEL(ret, lskip);
1366 PUSH_INSN(ret, location, pop);
1367 if (lskip && !popped) PUSH_LABEL(ret, lskip);
1368}
1369
1370static 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);
1371
1377static void
1378pm_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)
1379{
1380 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
1381
1382 // If this element is not popped, then we need to create the hash on the
1383 // stack. Neighboring plain assoc nodes should be grouped together (either
1384 // by newhash or hash merge). Double splat nodes should be merged using the
1385 // merge_kwd method call.
1386 const int max_stack_length = 0x100;
1387 const unsigned int min_tmp_hash_length = 0x800;
1388
1389 int stack_length = 0;
1390 bool first_chunk = true;
1391
1392 // This is an optimization wherein we keep track of whether or not the
1393 // previous element was a static literal. If it was, then we do not attempt
1394 // to check if we have a subhash that can be optimized. If it was not, then
1395 // we do check.
1396 bool static_literal = false;
1397
1398 DECL_ANCHOR(anchor);
1399
1400 // Convert pushed elements to a hash, and merge if needed.
1401#define FLUSH_CHUNK \
1402 if (stack_length) { \
1403 if (first_chunk) { \
1404 PUSH_SEQ(ret, anchor); \
1405 PUSH_INSN1(ret, location, newhash, INT2FIX(stack_length)); \
1406 first_chunk = false; \
1407 } \
1408 else { \
1409 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); \
1410 PUSH_INSN(ret, location, swap); \
1411 PUSH_SEQ(ret, anchor); \
1412 PUSH_SEND(ret, location, id_core_hash_merge_ptr, INT2FIX(stack_length + 1)); \
1413 } \
1414 INIT_ANCHOR(anchor); \
1415 stack_length = 0; \
1416 }
1417
1418 for (size_t index = 0; index < elements->size; index++) {
1419 const pm_node_t *element = elements->nodes[index];
1420
1421 switch (PM_NODE_TYPE(element)) {
1422 case PM_ASSOC_NODE: {
1423 // Pre-allocation check (this branch can be omitted).
1424 if (
1425 (shareability == 0) &&
1426 PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL) && (
1427 (!static_literal && ((index + min_tmp_hash_length) < elements->size)) ||
1428 (first_chunk && stack_length == 0)
1429 )
1430 ) {
1431 // Count the elements that are statically-known.
1432 size_t count = 1;
1433 while (index + count < elements->size && PM_NODE_FLAG_P(elements->nodes[index + count], PM_NODE_FLAG_STATIC_LITERAL)) count++;
1434
1435 if ((first_chunk && stack_length == 0) || count >= min_tmp_hash_length) {
1436 // The subsequence of elements in this hash is long enough
1437 // to merit its own hash.
1438 VALUE ary = rb_ary_hidden_new(count);
1439
1440 // Create a hidden hash.
1441 for (size_t tmp_end = index + count; index < tmp_end; index++) {
1442 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[index];
1443
1444 VALUE elem[2] = {
1445 pm_static_literal_value(iseq, assoc->key, scope_node),
1446 pm_static_literal_value(iseq, assoc->value, scope_node)
1447 };
1448
1449 rb_ary_cat(ary, elem, 2);
1450 }
1451 index --;
1452
1453 VALUE hash = rb_hash_new_with_size(RARRAY_LEN(ary) / 2);
1454 rb_hash_bulk_insert(RARRAY_LEN(ary), RARRAY_CONST_PTR(ary), hash);
1455 hash = rb_obj_hide(hash);
1456 RB_OBJ_SET_FROZEN_SHAREABLE(hash);
1457
1458 // Emit optimized code.
1459 FLUSH_CHUNK;
1460 if (first_chunk) {
1461 PUSH_INSN1(ret, location, duphash, hash);
1462 first_chunk = false;
1463 }
1464 else {
1465 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1466 PUSH_INSN(ret, location, swap);
1467 PUSH_INSN1(ret, location, putobject, hash);
1468 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1469 }
1470
1471 break;
1472 }
1473 else {
1474 static_literal = true;
1475 }
1476 }
1477 else {
1478 static_literal = false;
1479 }
1480
1481 // If this is a plain assoc node, then we can compile it directly
1482 // and then add the total number of values on the stack.
1483 if (shareability == 0) {
1484 pm_compile_node(iseq, element, anchor, false, scope_node);
1485 }
1486 else {
1487 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
1488 pm_compile_shareable_constant_value(iseq, assoc->key, shareability, path, ret, scope_node, false);
1489 pm_compile_shareable_constant_value(iseq, assoc->value, shareability, path, ret, scope_node, false);
1490 }
1491
1492 if ((stack_length += 2) >= max_stack_length) FLUSH_CHUNK;
1493 break;
1494 }
1495 case PM_ASSOC_SPLAT_NODE: {
1496 FLUSH_CHUNK;
1497
1498 const pm_assoc_splat_node_t *assoc_splat = (const pm_assoc_splat_node_t *) element;
1499 bool empty_hash = assoc_splat->value != NULL && (
1500 (PM_NODE_TYPE_P(assoc_splat->value, PM_HASH_NODE) && ((const pm_hash_node_t *) assoc_splat->value)->elements.size == 0) ||
1501 PM_NODE_TYPE_P(assoc_splat->value, PM_NIL_NODE)
1502 );
1503
1504 bool first_element = first_chunk && stack_length == 0;
1505 bool last_element = index == elements->size - 1;
1506 bool only_element = first_element && last_element;
1507
1508 if (empty_hash) {
1509 if (only_element && argument) {
1510 // **{} appears at the only keyword argument in method call,
1511 // so it won't be modified.
1512 //
1513 // This is only done for method calls and not for literal
1514 // hashes, because literal hashes should always result in a
1515 // new hash.
1516 PUSH_INSN(ret, location, putnil);
1517 }
1518 else if (first_element) {
1519 // **{} appears as the first keyword argument, so it may be
1520 // modified. We need to create a fresh hash object.
1521 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1522 }
1523 // Any empty keyword splats that are not the first can be
1524 // ignored since merging an empty hash into the existing hash is
1525 // the same as not merging it.
1526 }
1527 else {
1528 if (only_element && argument) {
1529 // ** is only keyword argument in the method call. Use it
1530 // directly. This will be not be flagged as mutable. This is
1531 // only done for method calls and not for literal hashes,
1532 // because literal hashes should always result in a new
1533 // hash.
1534 if (shareability == 0) {
1535 PM_COMPILE_NOT_POPPED(element);
1536 }
1537 else {
1538 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node, false);
1539 }
1540 }
1541 else {
1542 // There is more than one keyword argument, or this is not a
1543 // method call. In that case, we need to add an empty hash
1544 // (if first keyword), or merge the hash to the accumulated
1545 // hash (if not the first keyword).
1546 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1547
1548 if (first_element) {
1549 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1550 }
1551 else {
1552 PUSH_INSN(ret, location, swap);
1553 }
1554
1555 if (shareability == 0) {
1556 PM_COMPILE_NOT_POPPED(element);
1557 }
1558 else {
1559 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node, false);
1560 }
1561
1562 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1563 }
1564 }
1565
1566 first_chunk = false;
1567 static_literal = false;
1568 break;
1569 }
1570 default:
1571 RUBY_ASSERT("Invalid node type for hash" && false);
1572 break;
1573 }
1574 }
1575
1576 FLUSH_CHUNK;
1577#undef FLUSH_CHUNK
1578}
1579
1580#define SPLATARRAY_FALSE 0
1581#define SPLATARRAY_TRUE 1
1582#define DUP_SINGLE_KW_SPLAT 2
1583
1584// This is details. Users should call pm_setup_args() instead.
1585static int
1586pm_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)
1587{
1588 const pm_node_location_t location = *node_location;
1589
1590 int orig_argc = 0;
1591 bool has_splat = false;
1592 bool has_keyword_splat = false;
1593
1594 if (arguments_node == NULL) {
1595 if (*flags & VM_CALL_FCALL) {
1596 *flags |= VM_CALL_VCALL;
1597 }
1598 }
1599 else {
1600 const pm_node_list_t *arguments = &arguments_node->arguments;
1601 has_keyword_splat = PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT);
1602
1603 // We count the number of elements post the splat node that are not keyword elements to
1604 // eventually pass as an argument to newarray
1605 int post_splat_counter = 0;
1606 const pm_node_t *argument;
1607
1608 PM_NODE_LIST_FOREACH(arguments, index, argument) {
1609 switch (PM_NODE_TYPE(argument)) {
1610 // A keyword hash node contains all keyword arguments as AssocNodes and AssocSplatNodes
1611 case PM_KEYWORD_HASH_NODE: {
1612 const pm_keyword_hash_node_t *keyword_arg = (const pm_keyword_hash_node_t *) argument;
1613 const pm_node_list_t *elements = &keyword_arg->elements;
1614
1615 if (has_keyword_splat || has_splat) {
1616 *flags |= VM_CALL_KW_SPLAT;
1617 has_keyword_splat = true;
1618
1619 if (elements->size > 1 || !(elements->size == 1 && PM_NODE_TYPE_P(elements->nodes[0], PM_ASSOC_SPLAT_NODE))) {
1620 // A new hash will be created for the keyword arguments
1621 // in this case, so mark the method as passing mutable
1622 // keyword splat.
1623 *flags |= VM_CALL_KW_SPLAT_MUT;
1624 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1625 }
1626 else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
1627 *flags |= VM_CALL_KW_SPLAT_MUT;
1628 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1629 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1630 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1631 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1632 }
1633 else {
1634 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1635 }
1636 }
1637 else {
1638 // We need to first figure out if all elements of the
1639 // KeywordHashNode are AssocNodes with symbol keys.
1640 if (PM_NODE_FLAG_P(keyword_arg, PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS)) {
1641 // If they are all symbol keys then we can pass them as
1642 // keyword arguments. The first thing we need to do is
1643 // deduplicate. We'll do this using the combination of a
1644 // Ruby hash and a Ruby array.
1645 VALUE stored_indices = rb_hash_new();
1646 VALUE keyword_indices = rb_ary_new_capa(elements->size);
1647
1648 size_t size = 0;
1649 for (size_t element_index = 0; element_index < elements->size; element_index++) {
1650 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1651
1652 // Retrieve the stored index from the hash for this
1653 // keyword.
1654 VALUE keyword = pm_static_literal_value(iseq, assoc->key, scope_node);
1655 VALUE stored_index = rb_hash_aref(stored_indices, keyword);
1656
1657 // If this keyword was already seen in the hash,
1658 // then mark the array at that index as false and
1659 // decrement the keyword size.
1660 if (!NIL_P(stored_index)) {
1661 rb_ary_store(keyword_indices, NUM2LONG(stored_index), Qfalse);
1662 size--;
1663 }
1664
1665 // Store (and possibly overwrite) the index for this
1666 // keyword in the hash, mark the array at that index
1667 // as true, and increment the keyword size.
1668 rb_hash_aset(stored_indices, keyword, ULONG2NUM(element_index));
1669 rb_ary_store(keyword_indices, (long) element_index, Qtrue);
1670 size++;
1671 }
1672
1673 *kw_arg = rb_xmalloc_mul_add(size, sizeof(VALUE), sizeof(struct rb_callinfo_kwarg));
1674 *flags |= VM_CALL_KWARG;
1675
1676 VALUE *keywords = (*kw_arg)->keywords;
1677 (*kw_arg)->references = 0;
1678 (*kw_arg)->keyword_len = (int) size;
1679
1680 size_t keyword_index = 0;
1681 for (size_t element_index = 0; element_index < elements->size; element_index++) {
1682 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1683 bool popped = true;
1684
1685 if (rb_ary_entry(keyword_indices, (long) element_index) == Qtrue) {
1686 keywords[keyword_index++] = pm_static_literal_value(iseq, assoc->key, scope_node);
1687 popped = false;
1688 }
1689
1690 PM_COMPILE(assoc->value);
1691 }
1692
1693 RUBY_ASSERT(keyword_index == size);
1694 }
1695 else {
1696 // If they aren't all symbol keys then we need to
1697 // construct a new hash and pass that as an argument.
1698 orig_argc++;
1699 *flags |= VM_CALL_KW_SPLAT;
1700
1701 size_t size = elements->size;
1702 if (size > 1) {
1703 // A new hash will be created for the keyword
1704 // arguments in this case, so mark the method as
1705 // passing mutable keyword splat.
1706 *flags |= VM_CALL_KW_SPLAT_MUT;
1707 }
1708
1709 for (size_t element_index = 0; element_index < size; element_index++) {
1710 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1711 PM_COMPILE_NOT_POPPED(assoc->key);
1712 PM_COMPILE_NOT_POPPED(assoc->value);
1713 }
1714
1715 PUSH_INSN1(ret, location, newhash, INT2FIX(size * 2));
1716 }
1717 }
1718 break;
1719 }
1720 case PM_SPLAT_NODE: {
1721 *flags |= VM_CALL_ARGS_SPLAT;
1722 const pm_splat_node_t *splat_node = (const pm_splat_node_t *) argument;
1723
1724 if (splat_node->expression) {
1725 PM_COMPILE_NOT_POPPED(splat_node->expression);
1726 }
1727 else {
1728 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1729 PUSH_GETLOCAL(ret, location, index.index, index.level);
1730 }
1731
1732 bool first_splat = !has_splat;
1733
1734 if (first_splat) {
1735 // If this is the first splat array seen and it's not the
1736 // last parameter, we want splatarray to dup it.
1737 //
1738 // foo(a, *b, c)
1739 // ^^
1740 if (index + 1 < arguments->size || has_regular_blockarg) {
1741 PUSH_INSN1(ret, location, splatarray, (*dup_rest & SPLATARRAY_TRUE) ? Qtrue : Qfalse);
1742 if (*dup_rest & SPLATARRAY_TRUE) *dup_rest &= ~SPLATARRAY_TRUE;
1743 }
1744 // If this is the first spalt array seen and it's the last
1745 // parameter, we don't want splatarray to dup it.
1746 //
1747 // foo(a, *b)
1748 // ^^
1749 else {
1750 PUSH_INSN1(ret, location, splatarray, Qfalse);
1751 }
1752 }
1753 else {
1754 // If this is not the first splat array seen and it is also
1755 // the last parameter, we don't want splatarray to dup it
1756 // and we need to concat the array.
1757 //
1758 // foo(a, *b, *c)
1759 // ^^
1760 PUSH_INSN(ret, location, concattoarray);
1761 }
1762
1763 has_splat = true;
1764 post_splat_counter = 0;
1765
1766 break;
1767 }
1768 case PM_FORWARDING_ARGUMENTS_NODE: { // not counted in argc return value
1769 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
1770
1771 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
1772 *flags |= VM_CALL_FORWARDING;
1773
1774 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
1775 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1776
1777 break;
1778 }
1779
1780 if (has_splat) {
1781 // If we already have a splat, we're concatenating to existing array
1782 orig_argc += 1;
1783 } else {
1784 orig_argc += 2;
1785 }
1786
1787 *flags |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_BLOCKARG | VM_CALL_KW_SPLAT;
1788
1789 // Forwarding arguments nodes are treated as foo(*, **, &)
1790 // So foo(...) equals foo(*, **, &) and as such the local
1791 // table for this method is known in advance
1792 //
1793 // Push the *
1794 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1795 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1796
1797 if (has_splat) {
1798 // If we already have a splat, we need to concatenate arrays
1799 PUSH_INSN(ret, location, concattoarray);
1800 } else {
1801 PUSH_INSN1(ret, location, splatarray, Qfalse);
1802 }
1803
1804 // Push the **
1805 pm_local_index_t pow_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
1806 PUSH_GETLOCAL(ret, location, pow_local.index, pow_local.level);
1807
1808 // Push the &
1809 pm_local_index_t and_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
1810 PUSH_INSN2(ret, location, getblockparamproxy, INT2FIX(and_local.index + VM_ENV_DATA_SIZE - 1), INT2FIX(and_local.level));
1811
1812 break;
1813 }
1814 default: {
1815 post_splat_counter++;
1816 PM_COMPILE_NOT_POPPED(argument);
1817
1818 // If we have a splat and we've seen a splat, we need to process
1819 // everything after the splat.
1820 if (has_splat) {
1821 // Stack items are turned into an array and concatenated in
1822 // the following cases:
1823 //
1824 // If the next node is a splat:
1825 //
1826 // foo(*a, b, *c)
1827 //
1828 // If the next node is a kwarg or kwarg splat:
1829 //
1830 // foo(*a, b, c: :d)
1831 // foo(*a, b, **c)
1832 //
1833 // If the next node is a forwarding argument:
1834 //
1835 // foo(*a, b, ...)
1836 //
1837 // If the next node is NULL (we have hit the end):
1838 //
1839 // foo(*a, b)
1840 if (index == arguments->size - 1) {
1841 RUBY_ASSERT(post_splat_counter > 0);
1842 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(post_splat_counter));
1843 }
1844 else {
1845 pm_node_t *next_arg = arguments->nodes[index + 1];
1846
1847 switch (PM_NODE_TYPE(next_arg)) {
1848 // A keyword hash node contains all keyword arguments as AssocNodes and AssocSplatNodes
1849 case PM_KEYWORD_HASH_NODE: {
1850 PUSH_INSN1(ret, location, newarray, INT2FIX(post_splat_counter));
1851 PUSH_INSN(ret, location, concatarray);
1852 break;
1853 }
1854 case PM_SPLAT_NODE: {
1855 PUSH_INSN1(ret, location, newarray, INT2FIX(post_splat_counter));
1856 PUSH_INSN(ret, location, concatarray);
1857 break;
1858 }
1859 case PM_FORWARDING_ARGUMENTS_NODE: {
1860 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(post_splat_counter));
1861 break;
1862 }
1863 default:
1864 break;
1865 }
1866 }
1867 }
1868 else {
1869 orig_argc++;
1870 }
1871 }
1872 }
1873 }
1874 }
1875
1876 if (has_splat) orig_argc++;
1877 if (has_keyword_splat) orig_argc++;
1878 return orig_argc;
1879}
1880
1885static inline bool
1886pm_setup_args_dup_rest_p(const pm_node_t *node)
1887{
1888 switch (PM_NODE_TYPE(node)) {
1889 case PM_BACK_REFERENCE_READ_NODE:
1890 case PM_CLASS_VARIABLE_READ_NODE:
1891 case PM_CONSTANT_READ_NODE:
1892 case PM_FALSE_NODE:
1893 case PM_FLOAT_NODE:
1894 case PM_GLOBAL_VARIABLE_READ_NODE:
1895 case PM_IMAGINARY_NODE:
1896 case PM_INSTANCE_VARIABLE_READ_NODE:
1897 case PM_INTEGER_NODE:
1898 case PM_LAMBDA_NODE:
1899 case PM_LOCAL_VARIABLE_READ_NODE:
1900 case PM_NIL_NODE:
1901 case PM_NUMBERED_REFERENCE_READ_NODE:
1902 case PM_RATIONAL_NODE:
1903 case PM_REGULAR_EXPRESSION_NODE:
1904 case PM_SELF_NODE:
1905 case PM_STRING_NODE:
1906 case PM_SYMBOL_NODE:
1907 case PM_TRUE_NODE:
1908 return false;
1909 case PM_CONSTANT_PATH_NODE: {
1910 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
1911 if (cast->parent != NULL) {
1912 return pm_setup_args_dup_rest_p(cast->parent);
1913 }
1914 return false;
1915 }
1916 case PM_IMPLICIT_NODE:
1917 return pm_setup_args_dup_rest_p(((const pm_implicit_node_t *) node)->value);
1918 case PM_ARRAY_NODE: {
1919 const pm_array_node_t *cast = (const pm_array_node_t *) node;
1920 for (size_t index = 0; index < cast->elements.size; index++) {
1921 if (pm_setup_args_dup_rest_p(cast->elements.nodes[index])) {
1922 return true;
1923 }
1924 }
1925 return false;
1926 }
1927 default:
1928 return true;
1929 }
1930}
1931
1935static int
1936pm_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)
1937{
1938 int dup_rest = SPLATARRAY_TRUE;
1939
1940 const pm_node_list_t *arguments;
1941 size_t arguments_size;
1942
1943 // Calls like foo(1, *f, **hash) that use splat and kwsplat could be
1944 // eligible for eliding duping the rest array (dup_reset=false).
1945 if (
1946 arguments_node != NULL &&
1947 (arguments = &arguments_node->arguments, arguments_size = arguments->size) >= 2 &&
1948 PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT) &&
1949 !PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS) &&
1950 PM_NODE_TYPE_P(arguments->nodes[arguments_size - 1], PM_KEYWORD_HASH_NODE)
1951 ) {
1952 // Start by assuming that dup_rest=false, then check each element of the
1953 // hash to ensure we don't need to flip it back to true (in case one of
1954 // the elements could potentially mutate the array).
1955 dup_rest = SPLATARRAY_FALSE;
1956
1957 const pm_keyword_hash_node_t *keyword_hash = (const pm_keyword_hash_node_t *) arguments->nodes[arguments_size - 1];
1958 const pm_node_list_t *elements = &keyword_hash->elements;
1959
1960 for (size_t index = 0; dup_rest == SPLATARRAY_FALSE && index < elements->size; index++) {
1961 const pm_node_t *element = elements->nodes[index];
1962
1963 switch (PM_NODE_TYPE(element)) {
1964 case PM_ASSOC_NODE: {
1965 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
1966 if (pm_setup_args_dup_rest_p(assoc->key) || pm_setup_args_dup_rest_p(assoc->value)) dup_rest = SPLATARRAY_TRUE;
1967 break;
1968 }
1969 case PM_ASSOC_SPLAT_NODE: {
1970 const pm_assoc_splat_node_t *assoc = (const pm_assoc_splat_node_t *) element;
1971 if (assoc->value != NULL && pm_setup_args_dup_rest_p(assoc->value)) dup_rest = SPLATARRAY_TRUE;
1972 break;
1973 }
1974 default:
1975 break;
1976 }
1977 }
1978 }
1979
1980 int initial_dup_rest = dup_rest;
1981 int argc;
1982
1983 if (block && PM_NODE_TYPE_P(block, PM_BLOCK_ARGUMENT_NODE)) {
1984 // We compile the `&block_arg` expression first and stitch it later
1985 // since the nature of the expression influences whether splat should
1986 // duplicate the array.
1987 bool regular_block_arg = true;
1988 const pm_node_t *block_expr = ((const pm_block_argument_node_t *)block)->expression;
1989
1990 if (block_expr && pm_setup_args_dup_rest_p(block_expr)) {
1991 dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
1992 initial_dup_rest = dup_rest;
1993 }
1994
1995 DECL_ANCHOR(block_arg);
1996 pm_compile_node(iseq, block, block_arg, false, scope_node);
1997
1998 *flags |= VM_CALL_ARGS_BLOCKARG;
1999
2000 if (LIST_INSN_SIZE_ONE(block_arg)) {
2001 LINK_ELEMENT *elem = FIRST_ELEMENT(block_arg);
2002 if (IS_INSN(elem)) {
2003 INSN *iobj = (INSN *) elem;
2004 if (iobj->insn_id == BIN(getblockparam)) {
2005 iobj->insn_id = BIN(getblockparamproxy);
2006 }
2007
2008 // Allow splat without duplication for simple one-instruction
2009 // block arguments like `&arg`. It is known that this
2010 // optimization can be too aggressive in some cases. See
2011 // [Bug #16504].
2012 regular_block_arg = false;
2013 }
2014 }
2015
2016 argc = pm_setup_args_core(arguments_node, block, flags, regular_block_arg, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
2017 PUSH_SEQ(ret, block_arg);
2018 }
2019 else {
2020 argc = pm_setup_args_core(arguments_node, block, flags, false, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
2021 }
2022
2023 // If the dup_rest flag was consumed while compiling the arguments (which
2024 // effectively means we found the splat node), then it would have changed
2025 // during the call to pm_setup_args_core. In this case, we want to add the
2026 // VM_CALL_ARGS_SPLAT_MUT flag.
2027 if (*flags & VM_CALL_ARGS_SPLAT && dup_rest != initial_dup_rest) {
2028 *flags |= VM_CALL_ARGS_SPLAT_MUT;
2029 }
2030
2031 return argc;
2032}
2033
2044static void
2045pm_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)
2046{
2047 const pm_node_location_t location = *node_location;
2048 if (!popped) PUSH_INSN(ret, location, putnil);
2049
2050 PM_COMPILE_NOT_POPPED(node->receiver);
2051
2052 int boff = (node->block == NULL ? 0 : 1);
2053 int flag = PM_NODE_TYPE_P(node->receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
2054 struct rb_callinfo_kwarg *keywords = NULL;
2055 int argc = pm_setup_args(node->arguments, (const pm_node_t *) node->block, &flag, &keywords, iseq, ret, scope_node, node_location);
2056
2057 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2058 if (boff) {
2059 PUSH_INSN(ret, location, splatkw);
2060 }
2061 else {
2062 PUSH_INSN(ret, location, dup);
2063 PUSH_INSN(ret, location, splatkw);
2064 PUSH_INSN(ret, location, pop);
2065 }
2066 }
2067
2068 int dup_argn = argc + 1 + boff;
2069 int keyword_len = 0;
2070
2071 if (keywords) {
2072 keyword_len = keywords->keyword_len;
2073 dup_argn += keyword_len;
2074 }
2075
2076 PUSH_INSN1(ret, location, dupn, INT2FIX(dup_argn));
2077 PUSH_SEND_R(ret, location, idAREF, INT2FIX(argc), NULL, INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2078 PM_COMPILE_NOT_POPPED(node->value);
2079
2080 ID id_operator = pm_constant_id_lookup(scope_node, node->binary_operator);
2081 PUSH_SEND(ret, location, id_operator, INT2FIX(1));
2082
2083 if (!popped) {
2084 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2085 }
2086 if (flag & VM_CALL_ARGS_SPLAT) {
2087 if (flag & VM_CALL_KW_SPLAT) {
2088 PUSH_INSN1(ret, location, topn, INT2FIX(2 + boff));
2089
2090 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2091 PUSH_INSN1(ret, location, splatarray, Qtrue);
2092 flag |= VM_CALL_ARGS_SPLAT_MUT;
2093 }
2094
2095 PUSH_INSN(ret, location, swap);
2096 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2097 PUSH_INSN1(ret, location, setn, INT2FIX(2 + boff));
2098 PUSH_INSN(ret, location, pop);
2099 }
2100 else {
2101 if (boff > 0) {
2102 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2103 PUSH_INSN(ret, location, swap);
2104 PUSH_INSN(ret, location, pop);
2105 }
2106 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2107 PUSH_INSN(ret, location, swap);
2108 PUSH_INSN1(ret, location, splatarray, Qtrue);
2109 PUSH_INSN(ret, location, swap);
2110 flag |= VM_CALL_ARGS_SPLAT_MUT;
2111 }
2112 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2113 if (boff > 0) {
2114 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2115 PUSH_INSN(ret, location, pop);
2116 PUSH_INSN(ret, location, pop);
2117 }
2118 }
2119
2120 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc), NULL, INT2FIX(flag), keywords);
2121 }
2122 else if (flag & VM_CALL_KW_SPLAT) {
2123 if (boff > 0) {
2124 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2125 PUSH_INSN(ret, location, swap);
2126 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2127 PUSH_INSN(ret, location, pop);
2128 }
2129 PUSH_INSN(ret, location, swap);
2130 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2131 }
2132 else if (keyword_len) {
2133 PUSH_INSN(ret, location, dup);
2134 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 2));
2135 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 1));
2136 PUSH_INSN(ret, location, pop);
2137 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2138 }
2139 else {
2140 if (boff > 0) {
2141 PUSH_INSN(ret, location, swap);
2142 }
2143 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2144 }
2145
2146 PUSH_INSN(ret, location, pop);
2147}
2148
2161static void
2162pm_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)
2163{
2164 const pm_node_location_t location = *node_location;
2165 if (!popped) PUSH_INSN(ret, location, putnil);
2166 PM_COMPILE_NOT_POPPED(receiver);
2167
2168 int boff = (block == NULL ? 0 : 1);
2169 int flag = PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
2170 struct rb_callinfo_kwarg *keywords = NULL;
2171 int argc = pm_setup_args(arguments, (const pm_node_t *) block, &flag, &keywords, iseq, ret, scope_node, node_location);
2172
2173 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2174 if (boff) {
2175 PUSH_INSN(ret, location, splatkw);
2176 }
2177 else {
2178 PUSH_INSN(ret, location, dup);
2179 PUSH_INSN(ret, location, splatkw);
2180 PUSH_INSN(ret, location, pop);
2181 }
2182 }
2183
2184 int dup_argn = argc + 1 + boff;
2185 int keyword_len = 0;
2186
2187 if (keywords) {
2188 keyword_len = keywords->keyword_len;
2189 dup_argn += keyword_len;
2190 }
2191
2192 PUSH_INSN1(ret, location, dupn, INT2FIX(dup_argn));
2193 PUSH_SEND_R(ret, location, idAREF, INT2FIX(argc), NULL, INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2194
2195 LABEL *label = NEW_LABEL(location.line);
2196 LABEL *lfin = NEW_LABEL(location.line);
2197
2198 PUSH_INSN(ret, location, dup);
2199 if (PM_NODE_TYPE_P(node, PM_INDEX_AND_WRITE_NODE)) {
2200 PUSH_INSNL(ret, location, branchunless, label);
2201 }
2202 else {
2203 PUSH_INSNL(ret, location, branchif, label);
2204 }
2205
2206 PUSH_INSN(ret, location, pop);
2207 PM_COMPILE_NOT_POPPED(value);
2208
2209 if (!popped) {
2210 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2211 }
2212
2213 if (flag & VM_CALL_ARGS_SPLAT) {
2214 if (flag & VM_CALL_KW_SPLAT) {
2215 PUSH_INSN1(ret, location, topn, INT2FIX(2 + boff));
2216 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2217 PUSH_INSN1(ret, location, splatarray, Qtrue);
2218 flag |= VM_CALL_ARGS_SPLAT_MUT;
2219 }
2220
2221 PUSH_INSN(ret, location, swap);
2222 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2223 PUSH_INSN1(ret, location, setn, INT2FIX(2 + boff));
2224 PUSH_INSN(ret, location, pop);
2225 }
2226 else {
2227 if (boff > 0) {
2228 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2229 PUSH_INSN(ret, location, swap);
2230 PUSH_INSN(ret, location, pop);
2231 }
2232 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2233 PUSH_INSN(ret, location, swap);
2234 PUSH_INSN1(ret, location, splatarray, Qtrue);
2235 PUSH_INSN(ret, location, swap);
2236 flag |= VM_CALL_ARGS_SPLAT_MUT;
2237 }
2238 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2239 if (boff > 0) {
2240 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2241 PUSH_INSN(ret, location, pop);
2242 PUSH_INSN(ret, location, pop);
2243 }
2244 }
2245
2246 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc), NULL, INT2FIX(flag), keywords);
2247 }
2248 else if (flag & VM_CALL_KW_SPLAT) {
2249 if (boff > 0) {
2250 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2251 PUSH_INSN(ret, location, swap);
2252 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2253 PUSH_INSN(ret, location, pop);
2254 }
2255
2256 PUSH_INSN(ret, location, swap);
2257 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2258 }
2259 else if (keyword_len) {
2260 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 1));
2261 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 0));
2262 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2263 }
2264 else {
2265 if (boff > 0) {
2266 PUSH_INSN(ret, location, swap);
2267 }
2268 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2269 }
2270
2271 PUSH_INSN(ret, location, pop);
2272 PUSH_INSNL(ret, location, jump, lfin);
2273 PUSH_LABEL(ret, label);
2274 if (!popped) {
2275 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2276 }
2277 PUSH_INSN1(ret, location, adjuststack, INT2FIX(dup_argn + 1));
2278 PUSH_LABEL(ret, lfin);
2279}
2280
2281// When we compile a pattern matching expression, we use the stack as a scratch
2282// space to store lots of different values (consider it like we have a pattern
2283// matching function and we need space for a bunch of different local
2284// variables). The "base index" refers to the index on the stack where we
2285// started compiling the pattern matching expression. These offsets from that
2286// base index indicate the location of the various locals we need.
2287#define PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE 0
2288#define PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING 1
2289#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P 2
2290#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE 3
2291#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY 4
2292
2293// A forward declaration because this is the recursive function that handles
2294// compiling a pattern. It can be reentered by nesting patterns, as in the case
2295// of arrays or hashes.
2296static 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 use_deconstructed_cache, unsigned int base_index);
2297
2302static int
2303pm_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)
2304{
2305 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2306 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2307
2308 PUSH_INSN(ret, location, dup);
2309 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2310
2311 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2312 PUSH_INSN1(ret, location, putobject, message);
2313 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2314 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(2));
2315 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2316
2317 PUSH_INSN1(ret, location, putobject, Qfalse);
2318 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2319
2320 PUSH_INSN(ret, location, pop);
2321 PUSH_INSN(ret, location, pop);
2322 PUSH_LABEL(ret, match_succeeded_label);
2323
2324 return COMPILE_OK;
2325}
2326
2332static int
2333pm_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)
2334{
2335 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2336 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2337
2338 PUSH_INSN(ret, location, dup);
2339 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2340
2341 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2342 PUSH_INSN1(ret, location, putobject, message);
2343 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2344 PUSH_INSN(ret, location, dup);
2345 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2346 PUSH_INSN1(ret, location, putobject, length);
2347 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(4));
2348 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2349
2350 PUSH_INSN1(ret, location, putobject, Qfalse);
2351 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2352
2353 PUSH_INSN(ret, location, pop);
2354 PUSH_INSN(ret, location, pop);
2355 PUSH_LABEL(ret, match_succeeded_label);
2356
2357 return COMPILE_OK;
2358}
2359
2365static int
2366pm_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)
2367{
2368 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2369 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2370
2371 PUSH_INSN(ret, location, dup);
2372 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2373 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2374
2375 VALUE operand = rb_fstring_lit("%p === %p does not return true");
2376 PUSH_INSN1(ret, location, putobject, operand);
2377
2378 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2379 PUSH_INSN1(ret, location, topn, INT2FIX(5));
2380 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2381 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2382 PUSH_INSN1(ret, location, putobject, Qfalse);
2383 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2384 PUSH_INSN(ret, location, pop);
2385 PUSH_INSN(ret, location, pop);
2386
2387 PUSH_LABEL(ret, match_succeeded_label);
2388 PUSH_INSN1(ret, location, setn, INT2FIX(2));
2389 PUSH_INSN(ret, location, pop);
2390 PUSH_INSN(ret, location, pop);
2391
2392 return COMPILE_OK;
2393}
2394
2401static int
2402pm_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 use_deconstructed_cache, unsigned int base_index)
2403{
2404 LABEL *matched_label = NEW_LABEL(pm_node_line_number(scope_node->parser, node));
2405 CHECK(pm_compile_pattern(iseq, scope_node, node, ret, matched_label, unmatched_label, in_single_pattern, use_deconstructed_cache, base_index));
2406 PUSH_LABEL(ret, matched_label);
2407 return COMPILE_OK;
2408}
2409
2415static int
2416pm_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)
2417{
2418 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2419
2420 if (use_deconstructed_cache) {
2421 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2422 PUSH_INSNL(ret, location, branchnil, deconstruct_label);
2423
2424 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2425 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2426
2427 PUSH_INSN(ret, location, pop);
2428 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE - 1));
2429 PUSH_INSNL(ret, location, jump, deconstructed_label);
2430 }
2431 else {
2432 PUSH_INSNL(ret, location, jump, deconstruct_label);
2433 }
2434
2435 PUSH_LABEL(ret, deconstruct_label);
2436 PUSH_INSN(ret, location, dup);
2437
2438 VALUE operand = ID2SYM(rb_intern("deconstruct"));
2439 PUSH_INSN1(ret, location, putobject, operand);
2440 PUSH_SEND(ret, location, idRespond_to, INT2FIX(1));
2441
2442 if (use_deconstructed_cache) {
2443 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE + 1));
2444 }
2445
2446 if (in_single_pattern) {
2447 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p does not respond to #deconstruct"), base_index + 1));
2448 }
2449
2450 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2451 PUSH_SEND(ret, location, rb_intern("deconstruct"), INT2FIX(0));
2452
2453 if (use_deconstructed_cache) {
2454 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2455 }
2456
2457 PUSH_INSN(ret, location, dup);
2458 PUSH_INSN1(ret, location, checktype, INT2FIX(T_ARRAY));
2459 PUSH_INSNL(ret, location, branchunless, type_error_label);
2460 PUSH_LABEL(ret, deconstructed_label);
2461
2462 return COMPILE_OK;
2463}
2464
2469static int
2470pm_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)
2471{
2472 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2473
2474 PUSH_INSN(ret, location, dup);
2475 PM_COMPILE_NOT_POPPED(node);
2476
2477 if (in_single_pattern) {
2478 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
2479 }
2480 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE));
2481 if (in_single_pattern) {
2482 CHECK(pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 3));
2483 }
2484 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2485 return COMPILE_OK;
2486}
2487
2492static void
2493pm_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)
2494{
2495 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2496 LABEL *key_error_label = NEW_LABEL(location.line);
2497 LABEL *cleanup_label = NEW_LABEL(location.line);
2498
2499 struct rb_callinfo_kwarg *kw_arg = rb_xmalloc_mul_add(2, sizeof(VALUE), sizeof(struct rb_callinfo_kwarg));
2500 kw_arg->references = 0;
2501 kw_arg->keyword_len = 2;
2502 kw_arg->keywords[0] = ID2SYM(rb_intern("matchee"));
2503 kw_arg->keywords[1] = ID2SYM(rb_intern("key"));
2504
2505 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2506 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2507 PUSH_INSNL(ret, location, branchif, key_error_label);
2508
2509 PUSH_INSN1(ret, location, putobject, rb_eNoMatchingPatternError);
2510 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2511
2512 {
2513 VALUE operand = rb_fstring_lit("%p: %s");
2514 PUSH_INSN1(ret, location, putobject, operand);
2515 }
2516
2517 PUSH_INSN1(ret, location, topn, INT2FIX(4));
2518 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2519 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2520 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2521 PUSH_INSNL(ret, location, jump, cleanup_label);
2522
2523 PUSH_LABEL(ret, key_error_label);
2524 PUSH_INSN1(ret, location, putobject, rb_eNoMatchingPatternKeyError);
2525 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2526
2527 {
2528 VALUE operand = rb_fstring_lit("%p: %s");
2529 PUSH_INSN1(ret, location, putobject, operand);
2530 }
2531
2532 PUSH_INSN1(ret, location, topn, INT2FIX(4));
2533 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2534 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2535 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2536 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2537 PUSH_SEND_R(ret, location, rb_intern("new"), INT2FIX(1), NULL, INT2FIX(VM_CALL_KWARG), kw_arg);
2538 PUSH_SEND(ret, location, id_core_raise, INT2FIX(1));
2539 PUSH_LABEL(ret, cleanup_label);
2540
2541 PUSH_INSN1(ret, location, adjuststack, INT2FIX(7));
2542 if (!popped) PUSH_INSN(ret, location, putnil);
2543 PUSH_INSNL(ret, location, jump, done_label);
2544 PUSH_INSN1(ret, location, dupn, INT2FIX(5));
2545 if (popped) PUSH_INSN(ret, location, putnil);
2546}
2547
2551static int
2552pm_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 use_deconstructed_cache, unsigned int base_index)
2553{
2554 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2555
2556 switch (PM_NODE_TYPE(node)) {
2557 case PM_ARRAY_PATTERN_NODE: {
2558 // Array patterns in pattern matching are triggered by using commas in
2559 // a pattern or wrapping it in braces. They are represented by a
2560 // ArrayPatternNode. This looks like:
2561 //
2562 // foo => [1, 2, 3]
2563 //
2564 // It can optionally have a splat in the middle of it, which can
2565 // optionally have a name attached.
2566 const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
2567
2568 const size_t requireds_size = cast->requireds.size;
2569 const size_t posts_size = cast->posts.size;
2570 const size_t minimum_size = requireds_size + posts_size;
2571
2572 bool rest_named = false;
2573 bool use_rest_size = false;
2574
2575 if (cast->rest != NULL) {
2576 rest_named = (PM_NODE_TYPE_P(cast->rest, PM_SPLAT_NODE) && ((const pm_splat_node_t *) cast->rest)->expression != NULL);
2577 use_rest_size = (rest_named || (!rest_named && posts_size > 0));
2578 }
2579
2580 LABEL *match_failed_label = NEW_LABEL(location.line);
2581 LABEL *type_error_label = NEW_LABEL(location.line);
2582 LABEL *deconstruct_label = NEW_LABEL(location.line);
2583 LABEL *deconstructed_label = NEW_LABEL(location.line);
2584
2585 if (use_rest_size) {
2586 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2587 PUSH_INSN(ret, location, swap);
2588 base_index++;
2589 }
2590
2591 if (cast->constant != NULL) {
2592 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2593 }
2594
2595 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));
2596
2597 PUSH_INSN(ret, location, dup);
2598 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2599 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2600 PUSH_SEND(ret, location, cast->rest == NULL ? idEq : idGE, INT2FIX(1));
2601 if (in_single_pattern) {
2602 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+)");
2603 CHECK(pm_compile_pattern_length_error(iseq, scope_node, node, ret, message, INT2FIX(minimum_size), base_index + 1));
2604 }
2605 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2606
2607 for (size_t index = 0; index < requireds_size; index++) {
2608 const pm_node_t *required = cast->requireds.nodes[index];
2609 PUSH_INSN(ret, location, dup);
2610 PUSH_INSN1(ret, location, putobject, INT2FIX(index));
2611 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2612 CHECK(pm_compile_pattern_match(iseq, scope_node, required, ret, match_failed_label, in_single_pattern, false, base_index + 1));
2613 }
2614
2615 if (cast->rest != NULL) {
2616 if (rest_named) {
2617 PUSH_INSN(ret, location, dup);
2618 PUSH_INSN1(ret, location, putobject, INT2FIX(requireds_size));
2619 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2620 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2621 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2622 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2623 PUSH_INSN1(ret, location, setn, INT2FIX(4));
2624 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2625 CHECK(pm_compile_pattern_match(iseq, scope_node, ((const pm_splat_node_t *) cast->rest)->expression, ret, match_failed_label, in_single_pattern, false, base_index + 1));
2626 }
2627 else if (posts_size > 0) {
2628 PUSH_INSN(ret, location, dup);
2629 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2630 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2631 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2632 PUSH_INSN1(ret, location, setn, INT2FIX(2));
2633 PUSH_INSN(ret, location, pop);
2634 }
2635 }
2636
2637 for (size_t index = 0; index < posts_size; index++) {
2638 const pm_node_t *post = cast->posts.nodes[index];
2639 PUSH_INSN(ret, location, dup);
2640
2641 PUSH_INSN1(ret, location, putobject, INT2FIX(requireds_size + index));
2642 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2643 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2644 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2645 CHECK(pm_compile_pattern_match(iseq, scope_node, post, ret, match_failed_label, in_single_pattern, false, base_index + 1));
2646 }
2647
2648 PUSH_INSN(ret, location, pop);
2649 if (use_rest_size) {
2650 PUSH_INSN(ret, location, pop);
2651 }
2652
2653 PUSH_INSNL(ret, location, jump, matched_label);
2654 PUSH_INSN(ret, location, putnil);
2655 if (use_rest_size) {
2656 PUSH_INSN(ret, location, putnil);
2657 }
2658
2659 PUSH_LABEL(ret, type_error_label);
2660 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2661 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2662
2663 {
2664 VALUE operand = rb_fstring_lit("deconstruct must return Array");
2665 PUSH_INSN1(ret, location, putobject, operand);
2666 }
2667
2668 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2669 PUSH_INSN(ret, location, pop);
2670
2671 PUSH_LABEL(ret, match_failed_label);
2672 PUSH_INSN(ret, location, pop);
2673 if (use_rest_size) {
2674 PUSH_INSN(ret, location, pop);
2675 }
2676
2677 PUSH_INSNL(ret, location, jump, unmatched_label);
2678 break;
2679 }
2680 case PM_FIND_PATTERN_NODE: {
2681 // Find patterns in pattern matching are triggered by using commas in
2682 // a pattern or wrapping it in braces and using a splat on both the left
2683 // and right side of the pattern. This looks like:
2684 //
2685 // foo => [*, 1, 2, 3, *]
2686 //
2687 // There can be any number of requireds in the middle. The splats on
2688 // both sides can optionally have names attached.
2689 const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
2690 const size_t size = cast->requireds.size;
2691
2692 LABEL *match_failed_label = NEW_LABEL(location.line);
2693 LABEL *type_error_label = NEW_LABEL(location.line);
2694 LABEL *deconstruct_label = NEW_LABEL(location.line);
2695 LABEL *deconstructed_label = NEW_LABEL(location.line);
2696
2697 if (cast->constant) {
2698 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2699 }
2700
2701 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));
2702
2703 PUSH_INSN(ret, location, dup);
2704 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2705 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2706 PUSH_SEND(ret, location, idGE, INT2FIX(1));
2707 if (in_single_pattern) {
2708 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));
2709 }
2710 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2711
2712 {
2713 LABEL *while_begin_label = NEW_LABEL(location.line);
2714 LABEL *next_loop_label = NEW_LABEL(location.line);
2715 LABEL *find_succeeded_label = NEW_LABEL(location.line);
2716 LABEL *find_failed_label = NEW_LABEL(location.line);
2717
2718 PUSH_INSN(ret, location, dup);
2719 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2720
2721 PUSH_INSN(ret, location, dup);
2722 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2723 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2724 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2725 PUSH_LABEL(ret, while_begin_label);
2726
2727 PUSH_INSN(ret, location, dup);
2728 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2729 PUSH_SEND(ret, location, idLE, INT2FIX(1));
2730 PUSH_INSNL(ret, location, branchunless, find_failed_label);
2731
2732 for (size_t index = 0; index < size; index++) {
2733 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2734 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2735
2736 if (index != 0) {
2737 PUSH_INSN1(ret, location, putobject, INT2FIX(index));
2738 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2739 }
2740
2741 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2742 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->requireds.nodes[index], ret, next_loop_label, in_single_pattern, false, base_index + 4));
2743 }
2744
2745 const pm_splat_node_t *left = cast->left;
2746
2747 if (left->expression != NULL) {
2748 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2749 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2750 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2751 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2752 CHECK(pm_compile_pattern_match(iseq, scope_node, left->expression, ret, find_failed_label, in_single_pattern, false, base_index + 4));
2753 }
2754
2755 RUBY_ASSERT(PM_NODE_TYPE_P(cast->right, PM_SPLAT_NODE));
2756 const pm_splat_node_t *right = (const pm_splat_node_t *) cast->right;
2757
2758 if (right->expression != NULL) {
2759 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2760 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2761 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2762 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2763 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2764 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2765 pm_compile_pattern_match(iseq, scope_node, right->expression, ret, find_failed_label, in_single_pattern, false, base_index + 4);
2766 }
2767
2768 PUSH_INSNL(ret, location, jump, find_succeeded_label);
2769
2770 PUSH_LABEL(ret, next_loop_label);
2771 PUSH_INSN1(ret, location, putobject, INT2FIX(1));
2772 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2773 PUSH_INSNL(ret, location, jump, while_begin_label);
2774
2775 PUSH_LABEL(ret, find_failed_label);
2776 PUSH_INSN1(ret, location, adjuststack, INT2FIX(3));
2777 if (in_single_pattern) {
2778 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2779
2780 {
2781 VALUE operand = rb_fstring_lit("%p does not match to find pattern");
2782 PUSH_INSN1(ret, location, putobject, operand);
2783 }
2784
2785 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2786 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(2));
2787 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2788
2789 PUSH_INSN1(ret, location, putobject, Qfalse);
2790 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2791
2792 PUSH_INSN(ret, location, pop);
2793 PUSH_INSN(ret, location, pop);
2794 }
2795 PUSH_INSNL(ret, location, jump, match_failed_label);
2796 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2797
2798 PUSH_LABEL(ret, find_succeeded_label);
2799 PUSH_INSN1(ret, location, adjuststack, INT2FIX(3));
2800 }
2801
2802 PUSH_INSN(ret, location, pop);
2803 PUSH_INSNL(ret, location, jump, matched_label);
2804 PUSH_INSN(ret, location, putnil);
2805
2806 PUSH_LABEL(ret, type_error_label);
2807 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2808 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2809
2810 {
2811 VALUE operand = rb_fstring_lit("deconstruct must return Array");
2812 PUSH_INSN1(ret, location, putobject, operand);
2813 }
2814
2815 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2816 PUSH_INSN(ret, location, pop);
2817
2818 PUSH_LABEL(ret, match_failed_label);
2819 PUSH_INSN(ret, location, pop);
2820 PUSH_INSNL(ret, location, jump, unmatched_label);
2821
2822 break;
2823 }
2824 case PM_HASH_PATTERN_NODE: {
2825 // Hash patterns in pattern matching are triggered by using labels and
2826 // values in a pattern or by using the ** operator. They are represented
2827 // by the HashPatternNode. This looks like:
2828 //
2829 // foo => { a: 1, b: 2, **bar }
2830 //
2831 // It can optionally have an assoc splat in the middle of it, which can
2832 // optionally have a name.
2833 const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
2834
2835 // We don't consider it a "rest" parameter if it's a ** that is unnamed.
2836 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);
2837 bool has_keys = cast->elements.size > 0 || cast->rest != NULL;
2838
2839 LABEL *match_failed_label = NEW_LABEL(location.line);
2840 LABEL *type_error_label = NEW_LABEL(location.line);
2841 VALUE keys = Qnil;
2842
2843 if (has_keys && !has_rest) {
2844 keys = rb_ary_new_capa(cast->elements.size);
2845
2846 for (size_t index = 0; index < cast->elements.size; index++) {
2847 const pm_node_t *element = cast->elements.nodes[index];
2848 RUBY_ASSERT(PM_NODE_TYPE_P(element, PM_ASSOC_NODE));
2849
2850 const pm_node_t *key = ((const pm_assoc_node_t *) element)->key;
2851 RUBY_ASSERT(PM_NODE_TYPE_P(key, PM_SYMBOL_NODE));
2852
2853 VALUE symbol = ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) key));
2854 rb_ary_push(keys, symbol);
2855 }
2856 }
2857
2858 if (cast->constant) {
2859 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2860 }
2861
2862 PUSH_INSN(ret, location, dup);
2863
2864 {
2865 VALUE operand = ID2SYM(rb_intern("deconstruct_keys"));
2866 PUSH_INSN1(ret, location, putobject, operand);
2867 }
2868
2869 PUSH_SEND(ret, location, idRespond_to, INT2FIX(1));
2870 if (in_single_pattern) {
2871 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p does not respond to #deconstruct_keys"), base_index + 1));
2872 }
2873 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2874
2875 if (NIL_P(keys)) {
2876 PUSH_INSN(ret, location, putnil);
2877 }
2878 else {
2879 rb_obj_hide(keys);
2880 RB_OBJ_SET_FROZEN_SHAREABLE(keys);
2881 PUSH_INSN1(ret, location, duparray, keys);
2882 RB_OBJ_WRITTEN(iseq, Qundef, keys);
2883 }
2884 PUSH_SEND(ret, location, rb_intern("deconstruct_keys"), INT2FIX(1));
2885
2886 PUSH_INSN(ret, location, dup);
2887 PUSH_INSN1(ret, location, checktype, INT2FIX(T_HASH));
2888 PUSH_INSNL(ret, location, branchunless, type_error_label);
2889
2890 if (has_rest) {
2891 PUSH_SEND(ret, location, rb_intern("dup"), INT2FIX(0));
2892 }
2893
2894 if (has_keys) {
2895 DECL_ANCHOR(match_values);
2896
2897 for (size_t index = 0; index < cast->elements.size; index++) {
2898 const pm_node_t *element = cast->elements.nodes[index];
2899 RUBY_ASSERT(PM_NODE_TYPE_P(element, PM_ASSOC_NODE));
2900
2901 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
2902 const pm_node_t *key = assoc->key;
2903 RUBY_ASSERT(PM_NODE_TYPE_P(key, PM_SYMBOL_NODE));
2904
2905 VALUE symbol = ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) key));
2906 PUSH_INSN(ret, location, dup);
2907 PUSH_INSN1(ret, location, putobject, symbol);
2908 PUSH_SEND(ret, location, rb_intern("key?"), INT2FIX(1));
2909
2910 if (in_single_pattern) {
2911 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2912
2913 PUSH_INSN(ret, location, dup);
2914 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2915
2916 {
2917 VALUE operand = rb_str_freeze(rb_sprintf("key not found: %+"PRIsVALUE, symbol));
2918 RB_OBJ_SET_SHAREABLE(operand);
2919 PUSH_INSN1(ret, location, putobject, operand);
2920 }
2921
2922 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 2));
2923 PUSH_INSN1(ret, location, putobject, Qtrue);
2924 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 3));
2925 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2926 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2927 PUSH_INSN1(ret, location, putobject, symbol);
2928 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2929
2930 PUSH_INSN1(ret, location, adjuststack, INT2FIX(4));
2931 PUSH_LABEL(ret, match_succeeded_label);
2932 }
2933
2934 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2935 PUSH_INSN(match_values, location, dup);
2936 PUSH_INSN1(match_values, location, putobject, symbol);
2937 PUSH_SEND(match_values, location, has_rest ? rb_intern("delete") : idAREF, INT2FIX(1));
2938
2939 const pm_node_t *value = assoc->value;
2940 if (PM_NODE_TYPE_P(value, PM_IMPLICIT_NODE)) {
2941 value = ((const pm_implicit_node_t *) value)->value;
2942 }
2943
2944 CHECK(pm_compile_pattern_match(iseq, scope_node, value, match_values, match_failed_label, in_single_pattern, false, base_index + 1));
2945 }
2946
2947 PUSH_SEQ(ret, match_values);
2948 }
2949 else {
2950 PUSH_INSN(ret, location, dup);
2951 PUSH_SEND(ret, location, idEmptyP, INT2FIX(0));
2952 if (in_single_pattern) {
2953 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p is not empty"), base_index + 1));
2954 }
2955 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2956 }
2957
2958 if (has_rest) {
2959 switch (PM_NODE_TYPE(cast->rest)) {
2960 case PM_NO_KEYWORDS_PARAMETER_NODE: {
2961 PUSH_INSN(ret, location, dup);
2962 PUSH_SEND(ret, location, idEmptyP, INT2FIX(0));
2963 if (in_single_pattern) {
2964 pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("rest of %p is not empty"), base_index + 1);
2965 }
2966 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2967 break;
2968 }
2969 case PM_ASSOC_SPLAT_NODE: {
2970 const pm_assoc_splat_node_t *splat = (const pm_assoc_splat_node_t *) cast->rest;
2971 PUSH_INSN(ret, location, dup);
2972 pm_compile_pattern_match(iseq, scope_node, splat->value, ret, match_failed_label, in_single_pattern, false, base_index + 1);
2973 break;
2974 }
2975 default:
2976 rb_bug("unreachable");
2977 break;
2978 }
2979 }
2980
2981 PUSH_INSN(ret, location, pop);
2982 PUSH_INSNL(ret, location, jump, matched_label);
2983 PUSH_INSN(ret, location, putnil);
2984
2985 PUSH_LABEL(ret, type_error_label);
2986 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2987 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2988
2989 {
2990 VALUE operand = rb_fstring_lit("deconstruct_keys must return Hash");
2991 PUSH_INSN1(ret, location, putobject, operand);
2992 }
2993
2994 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2995 PUSH_INSN(ret, location, pop);
2996
2997 PUSH_LABEL(ret, match_failed_label);
2998 PUSH_INSN(ret, location, pop);
2999 PUSH_INSNL(ret, location, jump, unmatched_label);
3000 break;
3001 }
3002 case PM_CAPTURE_PATTERN_NODE: {
3003 // Capture patterns allow you to pattern match against an element in a
3004 // pattern and also capture the value into a local variable. This looks
3005 // like:
3006 //
3007 // [1] => [Integer => foo]
3008 //
3009 // In this case the `Integer => foo` will be represented by a
3010 // CapturePatternNode, which has both a value (the pattern to match
3011 // against) and a target (the place to write the variable into).
3012 const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
3013
3014 LABEL *match_failed_label = NEW_LABEL(location.line);
3015
3016 PUSH_INSN(ret, location, dup);
3017 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->value, ret, match_failed_label, in_single_pattern, use_deconstructed_cache, base_index + 1));
3018 CHECK(pm_compile_pattern(iseq, scope_node, (const pm_node_t *) cast->target, ret, matched_label, match_failed_label, in_single_pattern, false, base_index));
3019 PUSH_INSN(ret, location, putnil);
3020
3021 PUSH_LABEL(ret, match_failed_label);
3022 PUSH_INSN(ret, location, pop);
3023 PUSH_INSNL(ret, location, jump, unmatched_label);
3024
3025 break;
3026 }
3027 case PM_LOCAL_VARIABLE_TARGET_NODE: {
3028 // Local variables can be targeted by placing identifiers in the place
3029 // of a pattern. For example, foo in bar. This results in the value
3030 // being matched being written to that local variable.
3031 const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
3032 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
3033
3034 PUSH_SETLOCAL(ret, location, index.index, index.level);
3035 PUSH_INSNL(ret, location, jump, matched_label);
3036 break;
3037 }
3038 case PM_ALTERNATION_PATTERN_NODE: {
3039 // Alternation patterns allow you to specify multiple patterns in a
3040 // single expression using the | operator.
3041 const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
3042
3043 LABEL *matched_left_label = NEW_LABEL(location.line);
3044 LABEL *unmatched_left_label = NEW_LABEL(location.line);
3045
3046 // First, we're going to attempt to match against the left pattern. If
3047 // that pattern matches, then we'll skip matching the right pattern.
3048 PUSH_INSN(ret, location, dup);
3049 CHECK(pm_compile_pattern(iseq, scope_node, cast->left, ret, matched_left_label, unmatched_left_label, in_single_pattern, use_deconstructed_cache, base_index + 1));
3050
3051 // If we get here, then we matched on the left pattern. In this case we
3052 // should pop out the duplicate value that we preemptively added to
3053 // match against the right pattern and then jump to the match label.
3054 PUSH_LABEL(ret, matched_left_label);
3055 PUSH_INSN(ret, location, pop);
3056 PUSH_INSNL(ret, location, jump, matched_label);
3057 PUSH_INSN(ret, location, putnil);
3058
3059 // If we get here, then we didn't match on the left pattern. In this
3060 // case we attempt to match against the right pattern.
3061 PUSH_LABEL(ret, unmatched_left_label);
3062 CHECK(pm_compile_pattern(iseq, scope_node, cast->right, ret, matched_label, unmatched_label, in_single_pattern, use_deconstructed_cache, base_index));
3063 break;
3064 }
3065 case PM_PARENTHESES_NODE:
3066 // Parentheses are allowed to wrap expressions in pattern matching and
3067 // they do nothing since they can only wrap individual expressions and
3068 // not groups. In this case we'll recurse back into this same function
3069 // with the body of the parentheses.
3070 return pm_compile_pattern(iseq, scope_node, ((const pm_parentheses_node_t *) node)->body, ret, matched_label, unmatched_label, in_single_pattern, use_deconstructed_cache, base_index);
3071 case PM_PINNED_EXPRESSION_NODE:
3072 // Pinned expressions are a way to match against the value of an
3073 // expression that should be evaluated at runtime. This looks like:
3074 // foo in ^(bar). To compile these, we compile the expression as if it
3075 // were a literal value by falling through to the literal case.
3076 node = ((const pm_pinned_expression_node_t *) node)->expression;
3077 /* fallthrough */
3078 case PM_ARRAY_NODE:
3079 case PM_CLASS_VARIABLE_READ_NODE:
3080 case PM_CONSTANT_PATH_NODE:
3081 case PM_CONSTANT_READ_NODE:
3082 case PM_FALSE_NODE:
3083 case PM_FLOAT_NODE:
3084 case PM_GLOBAL_VARIABLE_READ_NODE:
3085 case PM_IMAGINARY_NODE:
3086 case PM_INSTANCE_VARIABLE_READ_NODE:
3087 case PM_IT_LOCAL_VARIABLE_READ_NODE:
3088 case PM_INTEGER_NODE:
3089 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
3090 case PM_INTERPOLATED_STRING_NODE:
3091 case PM_INTERPOLATED_SYMBOL_NODE:
3092 case PM_INTERPOLATED_X_STRING_NODE:
3093 case PM_LAMBDA_NODE:
3094 case PM_LOCAL_VARIABLE_READ_NODE:
3095 case PM_NIL_NODE:
3096 case PM_SOURCE_ENCODING_NODE:
3097 case PM_SOURCE_FILE_NODE:
3098 case PM_SOURCE_LINE_NODE:
3099 case PM_RANGE_NODE:
3100 case PM_RATIONAL_NODE:
3101 case PM_REGULAR_EXPRESSION_NODE:
3102 case PM_SELF_NODE:
3103 case PM_STRING_NODE:
3104 case PM_SYMBOL_NODE:
3105 case PM_TRUE_NODE:
3106 case PM_X_STRING_NODE: {
3107 // These nodes are all simple patterns, which means we'll use the
3108 // checkmatch instruction to match against them, which is effectively a
3109 // VM-level === operator.
3110 PM_COMPILE_NOT_POPPED(node);
3111 if (in_single_pattern) {
3112 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
3113 }
3114
3115 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE));
3116
3117 if (in_single_pattern) {
3118 pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 2);
3119 }
3120
3121 PUSH_INSNL(ret, location, branchif, matched_label);
3122 PUSH_INSNL(ret, location, jump, unmatched_label);
3123 break;
3124 }
3125 case PM_PINNED_VARIABLE_NODE: {
3126 // Pinned variables are a way to match against the value of a variable
3127 // without it looking like you're trying to write to the variable. This
3128 // looks like: foo in ^@bar. To compile these, we compile the variable
3129 // that they hold.
3130 const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
3131 CHECK(pm_compile_pattern(iseq, scope_node, cast->variable, ret, matched_label, unmatched_label, in_single_pattern, true, base_index));
3132 break;
3133 }
3134 case PM_IF_NODE:
3135 case PM_UNLESS_NODE: {
3136 // If and unless nodes can show up here as guards on `in` clauses. This
3137 // looks like:
3138 //
3139 // case foo
3140 // in bar if baz?
3141 // qux
3142 // end
3143 //
3144 // Because we know they're in the modifier form and they can't have any
3145 // variation on this pattern, we compile them differently (more simply)
3146 // here than we would in the normal compilation path.
3147 const pm_node_t *predicate;
3148 const pm_node_t *statement;
3149
3150 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3151 const pm_if_node_t *cast = (const pm_if_node_t *) node;
3152 predicate = cast->predicate;
3153
3154 RUBY_ASSERT(cast->statements != NULL && cast->statements->body.size == 1);
3155 statement = cast->statements->body.nodes[0];
3156 }
3157 else {
3158 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
3159 predicate = cast->predicate;
3160
3161 RUBY_ASSERT(cast->statements != NULL && cast->statements->body.size == 1);
3162 statement = cast->statements->body.nodes[0];
3163 }
3164
3165 CHECK(pm_compile_pattern_match(iseq, scope_node, statement, ret, unmatched_label, in_single_pattern, use_deconstructed_cache, base_index));
3166 PM_COMPILE_NOT_POPPED(predicate);
3167
3168 if (in_single_pattern) {
3169 LABEL *match_succeeded_label = NEW_LABEL(location.line);
3170
3171 PUSH_INSN(ret, location, dup);
3172 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3173 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
3174 }
3175 else {
3176 PUSH_INSNL(ret, location, branchunless, match_succeeded_label);
3177 }
3178
3179 {
3180 VALUE operand = rb_fstring_lit("guard clause does not return true");
3181 PUSH_INSN1(ret, location, putobject, operand);
3182 }
3183
3184 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
3185 PUSH_INSN1(ret, location, putobject, Qfalse);
3186 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
3187
3188 PUSH_INSN(ret, location, pop);
3189 PUSH_INSN(ret, location, pop);
3190
3191 PUSH_LABEL(ret, match_succeeded_label);
3192 }
3193
3194 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3195 PUSH_INSNL(ret, location, branchunless, unmatched_label);
3196 }
3197 else {
3198 PUSH_INSNL(ret, location, branchif, unmatched_label);
3199 }
3200
3201 PUSH_INSNL(ret, location, jump, matched_label);
3202 break;
3203 }
3204 default:
3205 // If we get here, then we have a node type that should not be in this
3206 // position. This would be a bug in the parser, because a different node
3207 // type should never have been created in this position in the tree.
3208 rb_bug("Unexpected node type in pattern matching expression: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
3209 break;
3210 }
3211
3212 return COMPILE_OK;
3213}
3214
3215#undef PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE
3216#undef PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING
3217#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P
3218#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE
3219#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY
3220
3221// Generate a scope node from the given node.
3222void
3223pm_scope_node_init(const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_t *previous)
3224{
3225 // This is very important, otherwise the scope node could be seen as having
3226 // certain flags set that _should not_ be set.
3227 memset(scope, 0, sizeof(pm_scope_node_t));
3228
3229 scope->base.type = PM_SCOPE_NODE;
3230 scope->base.location.start = node->location.start;
3231 scope->base.location.end = node->location.end;
3232
3233 scope->previous = previous;
3234 scope->ast_node = (pm_node_t *) node;
3235
3236 if (previous) {
3237 scope->parser = previous->parser;
3238 scope->encoding = previous->encoding;
3239 scope->filepath_encoding = previous->filepath_encoding;
3240 scope->constants = previous->constants;
3241 scope->coverage_enabled = previous->coverage_enabled;
3242 scope->script_lines = previous->script_lines;
3243 }
3244
3245 switch (PM_NODE_TYPE(node)) {
3246 case PM_BLOCK_NODE: {
3247 const pm_block_node_t *cast = (const pm_block_node_t *) node;
3248 scope->body = cast->body;
3249 scope->locals = cast->locals;
3250 scope->parameters = cast->parameters;
3251 break;
3252 }
3253 case PM_CLASS_NODE: {
3254 const pm_class_node_t *cast = (const pm_class_node_t *) node;
3255 scope->body = cast->body;
3256 scope->locals = cast->locals;
3257 break;
3258 }
3259 case PM_DEF_NODE: {
3260 const pm_def_node_t *cast = (const pm_def_node_t *) node;
3261 scope->parameters = (pm_node_t *) cast->parameters;
3262 scope->body = cast->body;
3263 scope->locals = cast->locals;
3264 break;
3265 }
3266 case PM_ENSURE_NODE: {
3267 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
3268 scope->body = (pm_node_t *) node;
3269
3270 if (cast->statements != NULL) {
3271 scope->base.location.start = cast->statements->base.location.start;
3272 scope->base.location.end = cast->statements->base.location.end;
3273 }
3274
3275 break;
3276 }
3277 case PM_FOR_NODE: {
3278 const pm_for_node_t *cast = (const pm_for_node_t *) node;
3279 scope->body = (pm_node_t *) cast->statements;
3280 break;
3281 }
3282 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
3283 RUBY_ASSERT(node->flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE);
3284 scope->body = (pm_node_t *) node;
3285 break;
3286 }
3287 case PM_LAMBDA_NODE: {
3288 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
3289 scope->parameters = cast->parameters;
3290 scope->body = cast->body;
3291 scope->locals = cast->locals;
3292
3293 if (cast->parameters != NULL) {
3294 scope->base.location.start = cast->parameters->location.start;
3295 }
3296 else {
3297 scope->base.location.start = cast->operator_loc.end;
3298 }
3299 break;
3300 }
3301 case PM_MODULE_NODE: {
3302 const pm_module_node_t *cast = (const pm_module_node_t *) node;
3303 scope->body = cast->body;
3304 scope->locals = cast->locals;
3305 break;
3306 }
3307 case PM_POST_EXECUTION_NODE: {
3308 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
3309 scope->body = (pm_node_t *) cast->statements;
3310 break;
3311 }
3312 case PM_PROGRAM_NODE: {
3313 const pm_program_node_t *cast = (const pm_program_node_t *) node;
3314 scope->body = (pm_node_t *) cast->statements;
3315 scope->locals = cast->locals;
3316 break;
3317 }
3318 case PM_RESCUE_NODE: {
3319 const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
3320 scope->body = (pm_node_t *) cast->statements;
3321 break;
3322 }
3323 case PM_RESCUE_MODIFIER_NODE: {
3324 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
3325 scope->body = (pm_node_t *) cast->rescue_expression;
3326 break;
3327 }
3328 case PM_SINGLETON_CLASS_NODE: {
3329 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
3330 scope->body = cast->body;
3331 scope->locals = cast->locals;
3332 break;
3333 }
3334 case PM_STATEMENTS_NODE: {
3335 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
3336 scope->body = (pm_node_t *) cast;
3337 break;
3338 }
3339 default:
3340 rb_bug("unreachable");
3341 break;
3342 }
3343}
3344
3345void
3346pm_scope_node_destroy(pm_scope_node_t *scope_node)
3347{
3348 if (scope_node->index_lookup_table) {
3349 st_free_table(scope_node->index_lookup_table);
3350 }
3351}
3352
3364static void
3365pm_compile_retry_end_label(rb_iseq_t *iseq, LINK_ANCHOR *const ret, LABEL *retry_end_l)
3366{
3367 INSN *iobj;
3368 LINK_ELEMENT *last_elem = LAST_ELEMENT(ret);
3369 iobj = IS_INSN(last_elem) ? (INSN*) last_elem : (INSN*) get_prev_insn((INSN*) last_elem);
3370 while (!IS_INSN_ID(iobj, send) && !IS_INSN_ID(iobj, invokesuper) && !IS_INSN_ID(iobj, sendforward) && !IS_INSN_ID(iobj, invokesuperforward)) {
3371 iobj = (INSN*) get_prev_insn(iobj);
3372 }
3373 ELEM_INSERT_NEXT(&iobj->link, (LINK_ELEMENT*) retry_end_l);
3374
3375 // LINK_ANCHOR has a pointer to the last element, but
3376 // ELEM_INSERT_NEXT does not update it even if we add an insn to the
3377 // last of LINK_ANCHOR. So this updates it manually.
3378 if (&iobj->link == LAST_ELEMENT(ret)) {
3379 ret->last = (LINK_ELEMENT*) retry_end_l;
3380 }
3381}
3382
3383static const char *
3384pm_iseq_builtin_function_name(const pm_scope_node_t *scope_node, const pm_node_t *receiver, ID method_id)
3385{
3386 const char *name = rb_id2name(method_id);
3387 static const char prefix[] = "__builtin_";
3388 const size_t prefix_len = sizeof(prefix) - 1;
3389
3390 if (receiver == NULL) {
3391 if (UNLIKELY(strncmp(prefix, name, prefix_len) == 0)) {
3392 // __builtin_foo
3393 return &name[prefix_len];
3394 }
3395 }
3396 else if (PM_NODE_TYPE_P(receiver, PM_CALL_NODE)) {
3397 if (PM_NODE_FLAG_P(receiver, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3398 const pm_call_node_t *cast = (const pm_call_node_t *) receiver;
3399 if (pm_constant_id_lookup(scope_node, cast->name) == rb_intern_const("__builtin")) {
3400 // __builtin.foo
3401 return name;
3402 }
3403 }
3404 }
3405 else if (PM_NODE_TYPE_P(receiver, PM_CONSTANT_READ_NODE)) {
3406 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) receiver;
3407 if (pm_constant_id_lookup(scope_node, cast->name) == rb_intern_const("Primitive")) {
3408 // Primitive.foo
3409 return name;
3410 }
3411 }
3412
3413 return NULL;
3414}
3415
3416// Compile Primitive.attr! :leaf, ...
3417static int
3418pm_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)
3419{
3420 if (arguments == NULL) {
3421 COMPILE_ERROR(iseq, node_location->line, "attr!: no argument");
3422 return COMPILE_NG;
3423 }
3424
3425 const pm_node_t *argument;
3426 PM_NODE_LIST_FOREACH(&arguments->arguments, index, argument) {
3427 if (!PM_NODE_TYPE_P(argument, PM_SYMBOL_NODE)) {
3428 COMPILE_ERROR(iseq, node_location->line, "non symbol argument to attr!: %s", pm_node_type_to_str(PM_NODE_TYPE(argument)));
3429 return COMPILE_NG;
3430 }
3431
3432 VALUE symbol = pm_static_literal_value(iseq, argument, scope_node);
3433 VALUE string = rb_sym2str(symbol);
3434
3435 if (strcmp(RSTRING_PTR(string), "leaf") == 0) {
3436 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_LEAF;
3437 }
3438 else if (strcmp(RSTRING_PTR(string), "inline_block") == 0) {
3439 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_INLINE_BLOCK;
3440 }
3441 else if (strcmp(RSTRING_PTR(string), "use_block") == 0) {
3442 iseq_set_use_block(iseq);
3443 }
3444 else if (strcmp(RSTRING_PTR(string), "c_trace") == 0) {
3445 // Let the iseq act like a C method in backtraces
3446 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_C_TRACE;
3447 }
3448 else {
3449 COMPILE_ERROR(iseq, node_location->line, "unknown argument to attr!: %s", RSTRING_PTR(string));
3450 return COMPILE_NG;
3451 }
3452 }
3453
3454 return COMPILE_OK;
3455}
3456
3457static int
3458pm_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)
3459{
3460 if (arguments == NULL) {
3461 COMPILE_ERROR(iseq, node_location->line, "arg!: no argument");
3462 return COMPILE_NG;
3463 }
3464
3465 if (arguments->arguments.size != 1) {
3466 COMPILE_ERROR(iseq, node_location->line, "arg!: too many argument");
3467 return COMPILE_NG;
3468 }
3469
3470 const pm_node_t *argument = arguments->arguments.nodes[0];
3471 if (!PM_NODE_TYPE_P(argument, PM_SYMBOL_NODE)) {
3472 COMPILE_ERROR(iseq, node_location->line, "non symbol argument to arg!: %s", pm_node_type_to_str(PM_NODE_TYPE(argument)));
3473 return COMPILE_NG;
3474 }
3475
3476 if (!popped) {
3477 ID name = parse_string_symbol(scope_node, ((const pm_symbol_node_t *) argument));
3478 int index = ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->local_table_size - get_local_var_idx(iseq, name);
3479
3480 debugs("id: %s idx: %d\n", rb_id2name(name), index);
3481 PUSH_GETLOCAL(ret, *node_location, index, get_lvar_level(iseq));
3482 }
3483
3484 return COMPILE_OK;
3485}
3486
3487static int
3488pm_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)
3489{
3490 const pm_node_t *ast_node = scope_node->ast_node;
3491 if (!PM_NODE_TYPE_P(ast_node, PM_DEF_NODE)) {
3492 rb_bug("mandatory_only?: not in method definition");
3493 return COMPILE_NG;
3494 }
3495
3496 const pm_def_node_t *def_node = (const pm_def_node_t *) ast_node;
3497 const pm_parameters_node_t *parameters_node = def_node->parameters;
3498 if (parameters_node == NULL) {
3499 rb_bug("mandatory_only?: in method definition with no parameters");
3500 return COMPILE_NG;
3501 }
3502
3503 const pm_node_t *body_node = def_node->body;
3504 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)) {
3505 rb_bug("mandatory_only?: not in method definition with plain statements");
3506 return COMPILE_NG;
3507 }
3508
3509 const pm_if_node_t *if_node = (const pm_if_node_t *) ((const pm_statements_node_t *) body_node)->body.nodes[0];
3510 if (if_node->predicate != ((const pm_node_t *) call_node)) {
3511 rb_bug("mandatory_only?: can't find mandatory node");
3512 return COMPILE_NG;
3513 }
3514
3515 pm_parameters_node_t parameters = {
3516 .base = parameters_node->base,
3517 .requireds = parameters_node->requireds
3518 };
3519
3520 const pm_def_node_t def = {
3521 .base = def_node->base,
3522 .name = def_node->name,
3523 .receiver = def_node->receiver,
3524 .parameters = &parameters,
3525 .body = (pm_node_t *) if_node->statements,
3526 .locals = {
3527 .ids = def_node->locals.ids,
3528 .size = parameters_node->requireds.size,
3529 .capacity = def_node->locals.capacity
3530 }
3531 };
3532
3533 pm_scope_node_t next_scope_node;
3534 pm_scope_node_init(&def.base, &next_scope_node, scope_node);
3535
3536 int error_state;
3537 const rb_iseq_t *mandatory_only_iseq = pm_iseq_new_with_opt(
3538 &next_scope_node,
3539 rb_iseq_base_label(iseq),
3540 rb_iseq_path(iseq),
3541 rb_iseq_realpath(iseq),
3542 node_location->line,
3543 NULL,
3544 0,
3545 ISEQ_TYPE_METHOD,
3546 ISEQ_COMPILE_DATA(iseq)->option,
3547 &error_state
3548 );
3549 RB_OBJ_WRITE(iseq, &ISEQ_BODY(iseq)->mandatory_only_iseq, (VALUE)mandatory_only_iseq);
3550
3551 if (error_state) {
3552 RUBY_ASSERT(ISEQ_BODY(iseq)->mandatory_only_iseq == NULL);
3553 rb_jump_tag(error_state);
3554 }
3555
3556 pm_scope_node_destroy(&next_scope_node);
3557 return COMPILE_OK;
3558}
3559
3560static int
3561pm_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)
3562{
3563 const pm_arguments_node_t *arguments = call_node->arguments;
3564
3565 if (parent_block != NULL) {
3566 COMPILE_ERROR(iseq, node_location->line, "should not call builtins here.");
3567 return COMPILE_NG;
3568 }
3569
3570#define BUILTIN_INLINE_PREFIX "_bi"
3571 char inline_func[sizeof(BUILTIN_INLINE_PREFIX) + DECIMAL_SIZE_OF(int)];
3572 bool cconst = false;
3573retry:;
3574 const struct rb_builtin_function *bf = iseq_builtin_function_lookup(iseq, builtin_func);
3575
3576 if (bf == NULL) {
3577 if (strcmp("cstmt!", builtin_func) == 0 || strcmp("cexpr!", builtin_func) == 0) {
3578 // ok
3579 }
3580 else if (strcmp("cconst!", builtin_func) == 0) {
3581 cconst = true;
3582 }
3583 else if (strcmp("cinit!", builtin_func) == 0) {
3584 // ignore
3585 return COMPILE_OK;
3586 }
3587 else if (strcmp("attr!", builtin_func) == 0) {
3588 return pm_compile_builtin_attr(iseq, scope_node, arguments, node_location);
3589 }
3590 else if (strcmp("arg!", builtin_func) == 0) {
3591 return pm_compile_builtin_arg(iseq, ret, scope_node, arguments, node_location, popped);
3592 }
3593 else if (strcmp("mandatory_only?", builtin_func) == 0) {
3594 if (popped) {
3595 rb_bug("mandatory_only? should be in if condition");
3596 }
3597 else if (!LIST_INSN_SIZE_ZERO(ret)) {
3598 rb_bug("mandatory_only? should be put on top");
3599 }
3600
3601 PUSH_INSN1(ret, *node_location, putobject, Qfalse);
3602 return pm_compile_builtin_mandatory_only_method(iseq, scope_node, call_node, node_location);
3603 }
3604 else if (1) {
3605 rb_bug("can't find builtin function:%s", builtin_func);
3606 }
3607 else {
3608 COMPILE_ERROR(iseq, node_location->line, "can't find builtin function:%s", builtin_func);
3609 return COMPILE_NG;
3610 }
3611
3612 int inline_index = node_location->line;
3613 snprintf(inline_func, sizeof(inline_func), BUILTIN_INLINE_PREFIX "%d", inline_index);
3614 builtin_func = inline_func;
3615 arguments = NULL;
3616 goto retry;
3617 }
3618
3619 if (cconst) {
3620 typedef VALUE(*builtin_func0)(void *, VALUE);
3621 VALUE const_val = (*(builtin_func0)(uintptr_t)bf->func_ptr)(NULL, Qnil);
3622 PUSH_INSN1(ret, *node_location, putobject, const_val);
3623 return COMPILE_OK;
3624 }
3625
3626 // fprintf(stderr, "func_name:%s -> %p\n", builtin_func, bf->func_ptr);
3627
3628 DECL_ANCHOR(args_seq);
3629
3630 int flags = 0;
3631 struct rb_callinfo_kwarg *keywords = NULL;
3632 int argc = pm_setup_args(arguments, call_node->block, &flags, &keywords, iseq, args_seq, scope_node, node_location);
3633
3634 if (argc != bf->argc) {
3635 COMPILE_ERROR(iseq, node_location->line, "argc is not match for builtin function:%s (expect %d but %d)", builtin_func, bf->argc, argc);
3636 return COMPILE_NG;
3637 }
3638
3639 unsigned int start_index;
3640 if (delegate_call_p(iseq, argc, args_seq, &start_index)) {
3641 PUSH_INSN2(ret, *node_location, opt_invokebuiltin_delegate, bf, INT2FIX(start_index));
3642 }
3643 else {
3644 PUSH_SEQ(ret, args_seq);
3645 PUSH_INSN1(ret, *node_location, invokebuiltin, bf);
3646 }
3647
3648 if (popped) PUSH_INSN(ret, *node_location, pop);
3649 return COMPILE_OK;
3650}
3651
3655static void
3656pm_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)
3657{
3658 const pm_location_t *message_loc = &call_node->message_loc;
3659 if (message_loc->start == NULL) message_loc = &call_node->base.location;
3660
3661 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, message_loc, call_node->base.node_id);
3662
3663 LABEL *else_label = NEW_LABEL(location.line);
3664 LABEL *end_label = NEW_LABEL(location.line);
3665 LABEL *retry_end_l = NEW_LABEL(location.line);
3666
3667 VALUE branches = Qfalse;
3668 rb_code_location_t code_location = { 0 };
3669 int node_id = location.node_id;
3670
3671 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3672 if (PM_BRANCH_COVERAGE_P(iseq)) {
3673 const uint8_t *cursors[3] = {
3674 call_node->closing_loc.end,
3675 call_node->arguments == NULL ? NULL : call_node->arguments->base.location.end,
3676 call_node->message_loc.end
3677 };
3678
3679 const uint8_t *end_cursor = cursors[0];
3680 end_cursor = (end_cursor == NULL || cursors[1] == NULL) ? cursors[1] : (end_cursor > cursors[1] ? end_cursor : cursors[1]);
3681 end_cursor = (end_cursor == NULL || cursors[2] == NULL) ? cursors[2] : (end_cursor > cursors[2] ? end_cursor : cursors[2]);
3682 if (!end_cursor) end_cursor = call_node->closing_loc.end;
3683
3684 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, call_node);
3685 const pm_line_column_t end_location = pm_newline_list_line_column(&scope_node->parser->newline_list, end_cursor, scope_node->parser->start_line);
3686
3687 code_location = (rb_code_location_t) {
3688 .beg_pos = { .lineno = start_location.line, .column = start_location.column },
3689 .end_pos = { .lineno = end_location.line, .column = end_location.column }
3690 };
3691
3692 branches = decl_branch_base(iseq, PTR2NUM(call_node), &code_location, "&.");
3693 }
3694
3695 PUSH_INSN(ret, location, dup);
3696 PUSH_INSNL(ret, location, branchnil, else_label);
3697
3698 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 0, "then", branches);
3699 }
3700
3701 LINK_ELEMENT *opt_new_prelude = LAST_ELEMENT(ret);
3702
3703 int flags = 0;
3704 struct rb_callinfo_kwarg *kw_arg = NULL;
3705
3706 int orig_argc = pm_setup_args(call_node->arguments, call_node->block, &flags, &kw_arg, iseq, ret, scope_node, &location);
3707 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
3708 const rb_iseq_t *block_iseq = NULL;
3709
3710 if (call_node->block != NULL && PM_NODE_TYPE_P(call_node->block, PM_BLOCK_NODE)) {
3711 // Scope associated with the block
3712 pm_scope_node_t next_scope_node;
3713 pm_scope_node_init(call_node->block, &next_scope_node, scope_node);
3714
3715 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));
3716 pm_scope_node_destroy(&next_scope_node);
3717 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
3718 }
3719 else {
3720 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3721 flags |= VM_CALL_VCALL;
3722 }
3723
3724 if (!flags) {
3725 flags |= VM_CALL_ARGS_SIMPLE;
3726 }
3727 }
3728
3729 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3730 flags |= VM_CALL_FCALL;
3731 }
3732
3733 if (!popped && PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3734 if (flags & VM_CALL_ARGS_BLOCKARG) {
3735 PUSH_INSN1(ret, location, topn, INT2FIX(1));
3736 if (flags & VM_CALL_ARGS_SPLAT) {
3737 PUSH_INSN1(ret, location, putobject, INT2FIX(-1));
3738 PUSH_SEND_WITH_FLAG(ret, location, idAREF, INT2FIX(1), INT2FIX(0));
3739 }
3740 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 3));
3741 PUSH_INSN(ret, location, pop);
3742 }
3743 else if (flags & VM_CALL_ARGS_SPLAT) {
3744 PUSH_INSN(ret, location, dup);
3745 PUSH_INSN1(ret, location, putobject, INT2FIX(-1));
3746 PUSH_SEND_WITH_FLAG(ret, location, idAREF, INT2FIX(1), INT2FIX(0));
3747 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 2));
3748 PUSH_INSN(ret, location, pop);
3749 }
3750 else {
3751 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 1));
3752 }
3753 }
3754
3755 if ((flags & VM_CALL_KW_SPLAT) && (flags & VM_CALL_ARGS_BLOCKARG) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
3756 PUSH_INSN(ret, location, splatkw);
3757 }
3758
3759 LABEL *not_basic_new = NEW_LABEL(location.line);
3760 LABEL *not_basic_new_finish = NEW_LABEL(location.line);
3761
3762 bool inline_new = ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction &&
3763 method_id == rb_intern("new") &&
3764 call_node->block == NULL &&
3765 (flags & VM_CALL_ARGS_BLOCKARG) == 0;
3766
3767 if (inline_new) {
3768 if (LAST_ELEMENT(ret) == opt_new_prelude) {
3769 PUSH_INSN(ret, location, putnil);
3770 PUSH_INSN(ret, location, swap);
3771 }
3772 else {
3773 ELEM_INSERT_NEXT(opt_new_prelude, &new_insn_body(iseq, location.line, location.node_id, BIN(swap), 0)->link);
3774 ELEM_INSERT_NEXT(opt_new_prelude, &new_insn_body(iseq, location.line, location.node_id, BIN(putnil), 0)->link);
3775 }
3776
3777 // Jump unless the receiver uses the "basic" implementation of "new"
3778 VALUE ci;
3779 if (flags & VM_CALL_FORWARDING) {
3780 ci = (VALUE)new_callinfo(iseq, method_id, orig_argc + 1, flags, kw_arg, 0);
3781 }
3782 else {
3783 ci = (VALUE)new_callinfo(iseq, method_id, orig_argc, flags, kw_arg, 0);
3784 }
3785
3786 PUSH_INSN2(ret, location, opt_new, ci, not_basic_new);
3787 LABEL_REF(not_basic_new);
3788 // optimized path
3789 PUSH_SEND_R(ret, location, rb_intern("initialize"), INT2FIX(orig_argc), block_iseq, INT2FIX(flags | VM_CALL_FCALL), kw_arg);
3790 PUSH_INSNL(ret, location, jump, not_basic_new_finish);
3791
3792 PUSH_LABEL(ret, not_basic_new);
3793 // Fall back to normal send
3794 PUSH_SEND_R(ret, location, method_id, INT2FIX(orig_argc), block_iseq, INT2FIX(flags), kw_arg);
3795 PUSH_INSN(ret, location, swap);
3796
3797 PUSH_LABEL(ret, not_basic_new_finish);
3798 PUSH_INSN(ret, location, pop);
3799 }
3800 else {
3801 PUSH_SEND_R(ret, location, method_id, INT2FIX(orig_argc), block_iseq, INT2FIX(flags), kw_arg);
3802 }
3803
3804 if (block_iseq && ISEQ_BODY(block_iseq)->catch_table) {
3805 pm_compile_retry_end_label(iseq, ret, retry_end_l);
3806 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, start, retry_end_l, block_iseq, retry_end_l);
3807 }
3808
3809 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3810 PUSH_INSNL(ret, location, jump, end_label);
3811 PUSH_LABEL(ret, else_label);
3812 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 1, "else", branches);
3813 PUSH_LABEL(ret, end_label);
3814 }
3815
3816 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) && !popped) {
3817 PUSH_INSN(ret, location, pop);
3818 }
3819
3820 if (popped) PUSH_INSN(ret, location, pop);
3821 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
3822}
3823
3828static inline VALUE
3829pm_compile_back_reference_ref(const pm_back_reference_read_node_t *node)
3830{
3831 const char *type = (const char *) (node->base.location.start + 1);
3832
3833 // Since a back reference is `$<char>`, Ruby represents the ID as an
3834 // rb_intern on the value after the `$`.
3835 return INT2FIX(rb_intern2(type, 1)) << 1 | 1;
3836}
3837
3842static inline VALUE
3843pm_compile_numbered_reference_ref(const pm_numbered_reference_read_node_t *node)
3844{
3845 return INT2FIX(node->number << 1);
3846}
3847
3848static void
3849pm_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)
3850{
3851#define PUSH_VAL(type) (in_condition ? Qtrue : rb_iseq_defined_string(type))
3852
3853 // in_condition is the same as compile.c's needstr
3854 enum defined_type dtype = DEFINED_NOT_DEFINED;
3855 const pm_node_location_t location = *node_location;
3856
3857 switch (PM_NODE_TYPE(node)) {
3858/* DEFINED_NIL ****************************************************************/
3859 case PM_NIL_NODE:
3860 // defined?(nil)
3861 // ^^^
3862 dtype = DEFINED_NIL;
3863 break;
3864/* DEFINED_IVAR ***************************************************************/
3865 case PM_INSTANCE_VARIABLE_READ_NODE: {
3866 // defined?(@a)
3867 // ^^
3868 const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
3869 ID name = pm_constant_id_lookup(scope_node, cast->name);
3870
3871 PUSH_INSN3(ret, location, definedivar, ID2SYM(name), get_ivar_ic_value(iseq, name), PUSH_VAL(DEFINED_IVAR));
3872
3873 return;
3874 }
3875/* DEFINED_LVAR ***************************************************************/
3876 case PM_LOCAL_VARIABLE_READ_NODE:
3877 // a = 1; defined?(a)
3878 // ^
3879 case PM_IT_LOCAL_VARIABLE_READ_NODE:
3880 // 1.then { defined?(it) }
3881 // ^^
3882 dtype = DEFINED_LVAR;
3883 break;
3884/* DEFINED_GVAR ***************************************************************/
3885 case PM_GLOBAL_VARIABLE_READ_NODE: {
3886 // defined?($a)
3887 // ^^
3888 const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
3889 ID name = pm_constant_id_lookup(scope_node, cast->name);
3890
3891 PUSH_INSN(ret, location, putnil);
3892 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_GVAR), ID2SYM(name), PUSH_VAL(DEFINED_GVAR));
3893
3894 return;
3895 }
3896/* DEFINED_CVAR ***************************************************************/
3897 case PM_CLASS_VARIABLE_READ_NODE: {
3898 // defined?(@@a)
3899 // ^^^
3900 const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
3901 ID name = pm_constant_id_lookup(scope_node, cast->name);
3902
3903 PUSH_INSN(ret, location, putnil);
3904 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CVAR), ID2SYM(name), PUSH_VAL(DEFINED_CVAR));
3905
3906 return;
3907 }
3908/* DEFINED_CONST **************************************************************/
3909 case PM_CONSTANT_READ_NODE: {
3910 // defined?(A)
3911 // ^
3912 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
3913 ID name = pm_constant_id_lookup(scope_node, cast->name);
3914
3915 PUSH_INSN(ret, location, putnil);
3916 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST), ID2SYM(name), PUSH_VAL(DEFINED_CONST));
3917
3918 return;
3919 }
3920/* DEFINED_YIELD **************************************************************/
3921 case PM_YIELD_NODE:
3922 // defined?(yield)
3923 // ^^^^^
3924 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
3925
3926 PUSH_INSN(ret, location, putnil);
3927 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_YIELD), 0, PUSH_VAL(DEFINED_YIELD));
3928
3929 return;
3930/* DEFINED_ZSUPER *************************************************************/
3931 case PM_SUPER_NODE: {
3932 // defined?(super 1, 2)
3933 // ^^^^^^^^^^
3934 const pm_super_node_t *cast = (const pm_super_node_t *) node;
3935
3936 if (cast->block != NULL && !PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE)) {
3937 dtype = DEFINED_EXPR;
3938 break;
3939 }
3940
3941 PUSH_INSN(ret, location, putnil);
3942 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3943 return;
3944 }
3945 case PM_FORWARDING_SUPER_NODE: {
3946 // defined?(super)
3947 // ^^^^^
3948 const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
3949
3950 if (cast->block != NULL) {
3951 dtype = DEFINED_EXPR;
3952 break;
3953 }
3954
3955 PUSH_INSN(ret, location, putnil);
3956 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3957 return;
3958 }
3959/* DEFINED_SELF ***************************************************************/
3960 case PM_SELF_NODE:
3961 // defined?(self)
3962 // ^^^^
3963 dtype = DEFINED_SELF;
3964 break;
3965/* DEFINED_TRUE ***************************************************************/
3966 case PM_TRUE_NODE:
3967 // defined?(true)
3968 // ^^^^
3969 dtype = DEFINED_TRUE;
3970 break;
3971/* DEFINED_FALSE **************************************************************/
3972 case PM_FALSE_NODE:
3973 // defined?(false)
3974 // ^^^^^
3975 dtype = DEFINED_FALSE;
3976 break;
3977/* DEFINED_ASGN ***************************************************************/
3978 case PM_CALL_AND_WRITE_NODE:
3979 // defined?(a.a &&= 1)
3980 // ^^^^^^^^^
3981 case PM_CALL_OPERATOR_WRITE_NODE:
3982 // defined?(a.a += 1)
3983 // ^^^^^^^^
3984 case PM_CALL_OR_WRITE_NODE:
3985 // defined?(a.a ||= 1)
3986 // ^^^^^^^^^
3987 case PM_CLASS_VARIABLE_AND_WRITE_NODE:
3988 // defined?(@@a &&= 1)
3989 // ^^^^^^^^^
3990 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
3991 // defined?(@@a += 1)
3992 // ^^^^^^^^
3993 case PM_CLASS_VARIABLE_OR_WRITE_NODE:
3994 // defined?(@@a ||= 1)
3995 // ^^^^^^^^^
3996 case PM_CLASS_VARIABLE_WRITE_NODE:
3997 // defined?(@@a = 1)
3998 // ^^^^^^^
3999 case PM_CONSTANT_AND_WRITE_NODE:
4000 // defined?(A &&= 1)
4001 // ^^^^^^^
4002 case PM_CONSTANT_OPERATOR_WRITE_NODE:
4003 // defined?(A += 1)
4004 // ^^^^^^
4005 case PM_CONSTANT_OR_WRITE_NODE:
4006 // defined?(A ||= 1)
4007 // ^^^^^^^
4008 case PM_CONSTANT_PATH_AND_WRITE_NODE:
4009 // defined?(A::A &&= 1)
4010 // ^^^^^^^^^^
4011 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE:
4012 // defined?(A::A += 1)
4013 // ^^^^^^^^^
4014 case PM_CONSTANT_PATH_OR_WRITE_NODE:
4015 // defined?(A::A ||= 1)
4016 // ^^^^^^^^^^
4017 case PM_CONSTANT_PATH_WRITE_NODE:
4018 // defined?(A::A = 1)
4019 // ^^^^^^^^
4020 case PM_CONSTANT_WRITE_NODE:
4021 // defined?(A = 1)
4022 // ^^^^^
4023 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE:
4024 // defined?($a &&= 1)
4025 // ^^^^^^^^
4026 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
4027 // defined?($a += 1)
4028 // ^^^^^^^
4029 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE:
4030 // defined?($a ||= 1)
4031 // ^^^^^^^^
4032 case PM_GLOBAL_VARIABLE_WRITE_NODE:
4033 // defined?($a = 1)
4034 // ^^^^^^
4035 case PM_INDEX_AND_WRITE_NODE:
4036 // defined?(a[1] &&= 1)
4037 // ^^^^^^^^^^
4038 case PM_INDEX_OPERATOR_WRITE_NODE:
4039 // defined?(a[1] += 1)
4040 // ^^^^^^^^^
4041 case PM_INDEX_OR_WRITE_NODE:
4042 // defined?(a[1] ||= 1)
4043 // ^^^^^^^^^^
4044 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE:
4045 // defined?(@a &&= 1)
4046 // ^^^^^^^^
4047 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
4048 // defined?(@a += 1)
4049 // ^^^^^^^
4050 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE:
4051 // defined?(@a ||= 1)
4052 // ^^^^^^^^
4053 case PM_INSTANCE_VARIABLE_WRITE_NODE:
4054 // defined?(@a = 1)
4055 // ^^^^^^
4056 case PM_LOCAL_VARIABLE_AND_WRITE_NODE:
4057 // defined?(a &&= 1)
4058 // ^^^^^^^
4059 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
4060 // defined?(a += 1)
4061 // ^^^^^^
4062 case PM_LOCAL_VARIABLE_OR_WRITE_NODE:
4063 // defined?(a ||= 1)
4064 // ^^^^^^^
4065 case PM_LOCAL_VARIABLE_WRITE_NODE:
4066 // defined?(a = 1)
4067 // ^^^^^
4068 case PM_MULTI_WRITE_NODE:
4069 // defined?((a, = 1))
4070 // ^^^^^^
4071 dtype = DEFINED_ASGN;
4072 break;
4073/* DEFINED_EXPR ***************************************************************/
4074 case PM_ALIAS_GLOBAL_VARIABLE_NODE:
4075 // defined?((alias $a $b))
4076 // ^^^^^^^^^^^
4077 case PM_ALIAS_METHOD_NODE:
4078 // defined?((alias a b))
4079 // ^^^^^^^^^
4080 case PM_AND_NODE:
4081 // defined?(a and b)
4082 // ^^^^^^^
4083 case PM_BREAK_NODE:
4084 // defined?(break 1)
4085 // ^^^^^^^
4086 case PM_CASE_MATCH_NODE:
4087 // defined?(case 1; in 1; end)
4088 // ^^^^^^^^^^^^^^^^^
4089 case PM_CASE_NODE:
4090 // defined?(case 1; when 1; end)
4091 // ^^^^^^^^^^^^^^^^^^^
4092 case PM_CLASS_NODE:
4093 // defined?(class Foo; end)
4094 // ^^^^^^^^^^^^^^
4095 case PM_DEF_NODE:
4096 // defined?(def a() end)
4097 // ^^^^^^^^^^^
4098 case PM_DEFINED_NODE:
4099 // defined?(defined?(a))
4100 // ^^^^^^^^^^^
4101 case PM_FLIP_FLOP_NODE:
4102 // defined?(not (a .. b))
4103 // ^^^^^^
4104 case PM_FLOAT_NODE:
4105 // defined?(1.0)
4106 // ^^^
4107 case PM_FOR_NODE:
4108 // defined?(for a in 1 do end)
4109 // ^^^^^^^^^^^^^^^^^
4110 case PM_IF_NODE:
4111 // defined?(if a then end)
4112 // ^^^^^^^^^^^^^
4113 case PM_IMAGINARY_NODE:
4114 // defined?(1i)
4115 // ^^
4116 case PM_INTEGER_NODE:
4117 // defined?(1)
4118 // ^
4119 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE:
4120 // defined?(not /#{1}/)
4121 // ^^^^^^
4122 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
4123 // defined?(/#{1}/)
4124 // ^^^^^^
4125 case PM_INTERPOLATED_STRING_NODE:
4126 // defined?("#{1}")
4127 // ^^^^^^
4128 case PM_INTERPOLATED_SYMBOL_NODE:
4129 // defined?(:"#{1}")
4130 // ^^^^^^^
4131 case PM_INTERPOLATED_X_STRING_NODE:
4132 // defined?(`#{1}`)
4133 // ^^^^^^
4134 case PM_LAMBDA_NODE:
4135 // defined?(-> {})
4136 // ^^^^^
4137 case PM_MATCH_LAST_LINE_NODE:
4138 // defined?(not //)
4139 // ^^^^^^
4140 case PM_MATCH_PREDICATE_NODE:
4141 // defined?(1 in 1)
4142 // ^^^^^^
4143 case PM_MATCH_REQUIRED_NODE:
4144 // defined?(1 => 1)
4145 // ^^^^^^
4146 case PM_MATCH_WRITE_NODE:
4147 // defined?(/(?<a>)/ =~ "")
4148 // ^^^^^^^^^^^^^^
4149 case PM_MODULE_NODE:
4150 // defined?(module A end)
4151 // ^^^^^^^^^^^^
4152 case PM_NEXT_NODE:
4153 // defined?(next 1)
4154 // ^^^^^^
4155 case PM_OR_NODE:
4156 // defined?(a or b)
4157 // ^^^^^^
4158 case PM_POST_EXECUTION_NODE:
4159 // defined?((END {}))
4160 // ^^^^^^^^
4161 case PM_RANGE_NODE:
4162 // defined?(1..1)
4163 // ^^^^
4164 case PM_RATIONAL_NODE:
4165 // defined?(1r)
4166 // ^^
4167 case PM_REDO_NODE:
4168 // defined?(redo)
4169 // ^^^^
4170 case PM_REGULAR_EXPRESSION_NODE:
4171 // defined?(//)
4172 // ^^
4173 case PM_RESCUE_MODIFIER_NODE:
4174 // defined?(a rescue b)
4175 // ^^^^^^^^^^
4176 case PM_RETRY_NODE:
4177 // defined?(retry)
4178 // ^^^^^
4179 case PM_RETURN_NODE:
4180 // defined?(return)
4181 // ^^^^^^
4182 case PM_SINGLETON_CLASS_NODE:
4183 // defined?(class << self; end)
4184 // ^^^^^^^^^^^^^^^^^^
4185 case PM_SOURCE_ENCODING_NODE:
4186 // defined?(__ENCODING__)
4187 // ^^^^^^^^^^^^
4188 case PM_SOURCE_FILE_NODE:
4189 // defined?(__FILE__)
4190 // ^^^^^^^^
4191 case PM_SOURCE_LINE_NODE:
4192 // defined?(__LINE__)
4193 // ^^^^^^^^
4194 case PM_STRING_NODE:
4195 // defined?("")
4196 // ^^
4197 case PM_SYMBOL_NODE:
4198 // defined?(:a)
4199 // ^^
4200 case PM_UNDEF_NODE:
4201 // defined?((undef a))
4202 // ^^^^^^^
4203 case PM_UNLESS_NODE:
4204 // defined?(unless a then end)
4205 // ^^^^^^^^^^^^^^^^^
4206 case PM_UNTIL_NODE:
4207 // defined?(until a do end)
4208 // ^^^^^^^^^^^^^^
4209 case PM_WHILE_NODE:
4210 // defined?(while a do end)
4211 // ^^^^^^^^^^^^^^
4212 case PM_X_STRING_NODE:
4213 // defined?(``)
4214 // ^^
4215 dtype = DEFINED_EXPR;
4216 break;
4217/* DEFINED_REF ****************************************************************/
4218 case PM_BACK_REFERENCE_READ_NODE: {
4219 // defined?($+)
4220 // ^^
4221 const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
4222 VALUE ref = pm_compile_back_reference_ref(cast);
4223
4224 PUSH_INSN(ret, location, putnil);
4225 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4226
4227 return;
4228 }
4229 case PM_NUMBERED_REFERENCE_READ_NODE: {
4230 // defined?($1)
4231 // ^^
4232 const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
4233 VALUE ref = pm_compile_numbered_reference_ref(cast);
4234
4235 PUSH_INSN(ret, location, putnil);
4236 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4237
4238 return;
4239 }
4240/* DEFINED_CONST_FROM *********************************************************/
4241 case PM_CONSTANT_PATH_NODE: {
4242 // defined?(A::A)
4243 // ^^^^
4244 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
4245 ID name = pm_constant_id_lookup(scope_node, cast->name);
4246
4247 if (cast->parent != NULL) {
4248 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4249 pm_compile_defined_expr0(iseq, cast->parent, node_location, ret, popped, scope_node, true, lfinish, false);
4250
4251 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4252 PM_COMPILE(cast->parent);
4253 }
4254 else {
4255 PUSH_INSN1(ret, location, putobject, rb_cObject);
4256 }
4257
4258 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST_FROM), ID2SYM(name), PUSH_VAL(DEFINED_CONST));
4259 return;
4260 }
4261/* Containers *****************************************************************/
4262 case PM_BEGIN_NODE: {
4263 // defined?(begin end)
4264 // ^^^^^^^^^
4265 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
4266
4267 if (cast->rescue_clause == NULL && cast->ensure_clause == NULL && cast->else_clause == NULL) {
4268 if (cast->statements == NULL) {
4269 // If we have empty statements, then we want to return "nil".
4270 dtype = DEFINED_NIL;
4271 }
4272 else if (cast->statements->body.size == 1) {
4273 // If we have a begin node that is wrapping a single statement
4274 // then we want to recurse down to that statement and compile
4275 // it.
4276 pm_compile_defined_expr0(iseq, cast->statements->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish, false);
4277 return;
4278 }
4279 else {
4280 // Otherwise, we have a begin wrapping multiple statements, in
4281 // which case this is defined as "expression".
4282 dtype = DEFINED_EXPR;
4283 }
4284 } else {
4285 // If we have any of the other clauses besides the main begin/end,
4286 // this is defined as "expression".
4287 dtype = DEFINED_EXPR;
4288 }
4289
4290 break;
4291 }
4292 case PM_PARENTHESES_NODE: {
4293 // defined?(())
4294 // ^^
4295 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
4296
4297 if (cast->body == NULL) {
4298 // If we have empty parentheses, then we want to return "nil".
4299 dtype = DEFINED_NIL;
4300 }
4301 else if (PM_NODE_TYPE_P(cast->body, PM_STATEMENTS_NODE) && !PM_NODE_FLAG_P(cast, PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS)) {
4302 // If we have a parentheses node that is wrapping a single statement
4303 // then we want to recurse down to that statement and compile it.
4304 pm_compile_defined_expr0(iseq, ((const pm_statements_node_t *) cast->body)->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish, false);
4305 return;
4306 }
4307 else {
4308 // Otherwise, we have parentheses wrapping multiple statements, in
4309 // which case this is defined as "expression".
4310 dtype = DEFINED_EXPR;
4311 }
4312
4313 break;
4314 }
4315 case PM_ARRAY_NODE: {
4316 // defined?([])
4317 // ^^
4318 const pm_array_node_t *cast = (const pm_array_node_t *) node;
4319
4320 if (cast->elements.size > 0 && !lfinish[1]) {
4321 lfinish[1] = NEW_LABEL(location.line);
4322 }
4323
4324 for (size_t index = 0; index < cast->elements.size; index++) {
4325 pm_compile_defined_expr0(iseq, cast->elements.nodes[index], node_location, ret, popped, scope_node, true, lfinish, false);
4326 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4327 }
4328
4329 dtype = DEFINED_EXPR;
4330 break;
4331 }
4332 case PM_HASH_NODE:
4333 // defined?({ a: 1 })
4334 // ^^^^^^^^
4335 case PM_KEYWORD_HASH_NODE: {
4336 // defined?(a(a: 1))
4337 // ^^^^
4338 const pm_node_list_t *elements;
4339
4340 if (PM_NODE_TYPE_P(node, PM_HASH_NODE)) {
4341 elements = &((const pm_hash_node_t *) node)->elements;
4342 }
4343 else {
4344 elements = &((const pm_keyword_hash_node_t *) node)->elements;
4345 }
4346
4347 if (elements->size > 0 && !lfinish[1]) {
4348 lfinish[1] = NEW_LABEL(location.line);
4349 }
4350
4351 for (size_t index = 0; index < elements->size; index++) {
4352 pm_compile_defined_expr0(iseq, elements->nodes[index], node_location, ret, popped, scope_node, true, lfinish, false);
4353 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4354 }
4355
4356 dtype = DEFINED_EXPR;
4357 break;
4358 }
4359 case PM_ASSOC_NODE: {
4360 // defined?({ a: 1 })
4361 // ^^^^
4362 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
4363
4364 pm_compile_defined_expr0(iseq, cast->key, node_location, ret, popped, scope_node, true, lfinish, false);
4365 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4366 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, true, lfinish, false);
4367
4368 return;
4369 }
4370 case PM_ASSOC_SPLAT_NODE: {
4371 // defined?({ **a })
4372 // ^^^^
4373 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
4374
4375 if (cast->value == NULL) {
4376 dtype = DEFINED_EXPR;
4377 break;
4378 }
4379
4380 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, true, lfinish, false);
4381 return;
4382 }
4383 case PM_IMPLICIT_NODE: {
4384 // defined?({ a: })
4385 // ^^
4386 const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
4387 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4388 return;
4389 }
4390 case PM_CALL_NODE: {
4391#define BLOCK_P(cast) ((cast)->block != NULL && PM_NODE_TYPE_P((cast)->block, PM_BLOCK_NODE))
4392
4393 // defined?(a(1, 2, 3))
4394 // ^^^^^^^^^^
4395 const pm_call_node_t *cast = ((const pm_call_node_t *) node);
4396
4397 if (BLOCK_P(cast)) {
4398 dtype = DEFINED_EXPR;
4399 break;
4400 }
4401
4402 if (cast->receiver || cast->arguments || (cast->block && PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE))) {
4403 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4404 if (!lfinish[2]) lfinish[2] = NEW_LABEL(location.line);
4405 }
4406
4407 if (cast->arguments) {
4408 pm_compile_defined_expr0(iseq, (const pm_node_t *) cast->arguments, node_location, ret, popped, scope_node, true, lfinish, false);
4409 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4410 }
4411
4412 if (cast->block && PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE)) {
4413 pm_compile_defined_expr0(iseq, cast->block, node_location, ret, popped, scope_node, true, lfinish, false);
4414 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4415 }
4416
4417 if (cast->receiver) {
4418 if (PM_NODE_TYPE_P(cast->receiver, PM_CALL_NODE) && !BLOCK_P((const pm_call_node_t *) cast->receiver)) {
4419 // Special behavior here where we chain calls together. This is
4420 // the only path that sets explicit_receiver to true.
4421 pm_compile_defined_expr0(iseq, cast->receiver, node_location, ret, popped, scope_node, true, lfinish, true);
4422 PUSH_INSNL(ret, location, branchunless, lfinish[2]);
4423
4424 const pm_call_node_t *receiver = (const pm_call_node_t *) cast->receiver;
4425 ID method_id = pm_constant_id_lookup(scope_node, receiver->name);
4426
4427 pm_compile_call(iseq, receiver, ret, popped, scope_node, method_id, NULL);
4428 }
4429 else {
4430 pm_compile_defined_expr0(iseq, cast->receiver, node_location, ret, popped, scope_node, true, lfinish, false);
4431 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4432 PM_COMPILE(cast->receiver);
4433 }
4434
4435 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
4436
4437 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4438 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_METHOD), rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4439 }
4440 else {
4441 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
4442
4443 PUSH_INSN(ret, location, putself);
4444 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4445
4446 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_FUNC), rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4447 }
4448
4449 return;
4450
4451#undef BLOCK_P
4452 }
4453 case PM_ARGUMENTS_NODE: {
4454 // defined?(a(1, 2, 3))
4455 // ^^^^^^^
4456 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
4457
4458 for (size_t index = 0; index < cast->arguments.size; index++) {
4459 pm_compile_defined_expr0(iseq, cast->arguments.nodes[index], node_location, ret, popped, scope_node, in_condition, lfinish, false);
4460 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4461 }
4462
4463 dtype = DEFINED_EXPR;
4464 break;
4465 }
4466 case PM_BLOCK_ARGUMENT_NODE:
4467 // defined?(a(&b))
4468 // ^^
4469 dtype = DEFINED_EXPR;
4470 break;
4471 case PM_FORWARDING_ARGUMENTS_NODE:
4472 // def a(...) = defined?(a(...))
4473 // ^^^
4474 dtype = DEFINED_EXPR;
4475 break;
4476 case PM_SPLAT_NODE: {
4477 // def a(*) = defined?(a(*))
4478 // ^
4479 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
4480
4481 if (cast->expression == NULL) {
4482 dtype = DEFINED_EXPR;
4483 break;
4484 }
4485
4486 pm_compile_defined_expr0(iseq, cast->expression, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4487
4488 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4489 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4490
4491 dtype = DEFINED_EXPR;
4492 break;
4493 }
4494 case PM_SHAREABLE_CONSTANT_NODE:
4495 // # shareable_constant_value: literal
4496 // defined?(A = 1)
4497 // ^^^^^
4498 pm_compile_defined_expr0(iseq, ((const pm_shareable_constant_node_t *) node)->write, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4499 return;
4500/* Unreachable (parameters) ***************************************************/
4501 case PM_BLOCK_LOCAL_VARIABLE_NODE:
4502 case PM_BLOCK_PARAMETER_NODE:
4503 case PM_BLOCK_PARAMETERS_NODE:
4504 case PM_FORWARDING_PARAMETER_NODE:
4505 case PM_IMPLICIT_REST_NODE:
4506 case PM_IT_PARAMETERS_NODE:
4507 case PM_PARAMETERS_NODE:
4508 case PM_KEYWORD_REST_PARAMETER_NODE:
4509 case PM_NO_KEYWORDS_PARAMETER_NODE:
4510 case PM_NUMBERED_PARAMETERS_NODE:
4511 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
4512 case PM_OPTIONAL_PARAMETER_NODE:
4513 case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
4514 case PM_REQUIRED_PARAMETER_NODE:
4515 case PM_REST_PARAMETER_NODE:
4516/* Unreachable (pattern matching) *********************************************/
4517 case PM_ALTERNATION_PATTERN_NODE:
4518 case PM_ARRAY_PATTERN_NODE:
4519 case PM_CAPTURE_PATTERN_NODE:
4520 case PM_FIND_PATTERN_NODE:
4521 case PM_HASH_PATTERN_NODE:
4522 case PM_PINNED_EXPRESSION_NODE:
4523 case PM_PINNED_VARIABLE_NODE:
4524/* Unreachable (indirect writes) **********************************************/
4525 case PM_CALL_TARGET_NODE:
4526 case PM_CLASS_VARIABLE_TARGET_NODE:
4527 case PM_CONSTANT_PATH_TARGET_NODE:
4528 case PM_CONSTANT_TARGET_NODE:
4529 case PM_GLOBAL_VARIABLE_TARGET_NODE:
4530 case PM_INDEX_TARGET_NODE:
4531 case PM_INSTANCE_VARIABLE_TARGET_NODE:
4532 case PM_LOCAL_VARIABLE_TARGET_NODE:
4533 case PM_MULTI_TARGET_NODE:
4534/* Unreachable (clauses) ******************************************************/
4535 case PM_ELSE_NODE:
4536 case PM_ENSURE_NODE:
4537 case PM_IN_NODE:
4538 case PM_RESCUE_NODE:
4539 case PM_WHEN_NODE:
4540/* Unreachable (miscellaneous) ************************************************/
4541 case PM_BLOCK_NODE:
4542 case PM_EMBEDDED_STATEMENTS_NODE:
4543 case PM_EMBEDDED_VARIABLE_NODE:
4544 case PM_MISSING_NODE:
4545 case PM_PRE_EXECUTION_NODE:
4546 case PM_PROGRAM_NODE:
4547 case PM_SCOPE_NODE:
4548 case PM_STATEMENTS_NODE:
4549 rb_bug("Unreachable node in defined?: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
4550 }
4551
4552 RUBY_ASSERT(dtype != DEFINED_NOT_DEFINED);
4553 PUSH_INSN1(ret, location, putobject, PUSH_VAL(dtype));
4554
4555#undef PUSH_VAL
4556}
4557
4558static void
4559pm_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)
4560{
4561 LINK_ELEMENT *lcur = ret->last;
4562 pm_compile_defined_expr0(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4563
4564 if (lfinish[1]) {
4565 LABEL *lstart = NEW_LABEL(node_location->line);
4566 LABEL *lend = NEW_LABEL(node_location->line);
4567
4568 struct rb_iseq_new_with_callback_callback_func *ifunc =
4569 rb_iseq_new_with_callback_new_callback(build_defined_rescue_iseq, NULL);
4570
4571 const rb_iseq_t *rescue = new_child_iseq_with_callback(
4572 iseq,
4573 ifunc,
4574 rb_str_concat(rb_str_new2("defined guard in "), ISEQ_BODY(iseq)->location.label),
4575 iseq,
4576 ISEQ_TYPE_RESCUE,
4577 0
4578 );
4579
4580 lstart->rescued = LABEL_RESCUE_BEG;
4581 lend->rescued = LABEL_RESCUE_END;
4582
4583 APPEND_LABEL(ret, lcur, lstart);
4584 PUSH_LABEL(ret, lend);
4585 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lfinish[1]);
4586 }
4587}
4588
4589static void
4590pm_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)
4591{
4592 LABEL *lfinish[3];
4593 LINK_ELEMENT *last = ret->last;
4594
4595 lfinish[0] = NEW_LABEL(node_location->line);
4596 lfinish[1] = 0;
4597 lfinish[2] = 0;
4598
4599 if (!popped) {
4600 pm_defined_expr(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish);
4601 }
4602
4603 if (lfinish[1]) {
4604 ELEM_INSERT_NEXT(last, &new_insn_body(iseq, node_location->line, node_location->node_id, BIN(putnil), 0)->link);
4605 PUSH_INSN(ret, *node_location, swap);
4606
4607 if (lfinish[2]) PUSH_LABEL(ret, lfinish[2]);
4608 PUSH_INSN(ret, *node_location, pop);
4609 PUSH_LABEL(ret, lfinish[1]);
4610
4611 }
4612
4613 PUSH_LABEL(ret, lfinish[0]);
4614}
4615
4616// This is exactly the same as add_ensure_iseq, except it compiled
4617// the node as a Prism node, and not a CRuby node
4618static void
4619pm_add_ensure_iseq(LINK_ANCHOR *const ret, rb_iseq_t *iseq, int is_return, pm_scope_node_t *scope_node)
4620{
4621 RUBY_ASSERT(can_add_ensure_iseq(iseq));
4622
4623 struct iseq_compile_data_ensure_node_stack *enlp =
4624 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack;
4625 struct iseq_compile_data_ensure_node_stack *prev_enlp = enlp;
4626 DECL_ANCHOR(ensure);
4627
4628 while (enlp) {
4629 if (enlp->erange != NULL) {
4630 DECL_ANCHOR(ensure_part);
4631 LABEL *lstart = NEW_LABEL(0);
4632 LABEL *lend = NEW_LABEL(0);
4633
4634 add_ensure_range(iseq, enlp->erange, lstart, lend);
4635
4636 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enlp->prev;
4637 PUSH_LABEL(ensure_part, lstart);
4638 bool popped = true;
4639 PM_COMPILE_INTO_ANCHOR(ensure_part, (const pm_node_t *) enlp->ensure_node);
4640 PUSH_LABEL(ensure_part, lend);
4641 PUSH_SEQ(ensure, ensure_part);
4642 }
4643 else {
4644 if (!is_return) {
4645 break;
4646 }
4647 }
4648 enlp = enlp->prev;
4649 }
4650 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = prev_enlp;
4651 PUSH_SEQ(ret, ensure);
4652}
4653
4654 struct pm_local_table_insert_ctx {
4655 pm_scope_node_t *scope_node;
4656 rb_ast_id_table_t *local_table_for_iseq;
4657 int local_index;
4658};
4659
4660static int
4661pm_local_table_insert_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
4662{
4663 if (!existing) {
4664 pm_constant_id_t constant_id = (pm_constant_id_t) *key;
4665 struct pm_local_table_insert_ctx * ctx = (struct pm_local_table_insert_ctx *) arg;
4666
4667 pm_scope_node_t *scope_node = ctx->scope_node;
4668 rb_ast_id_table_t *local_table_for_iseq = ctx->local_table_for_iseq;
4669 int local_index = ctx->local_index;
4670
4671 ID local = pm_constant_id_lookup(scope_node, constant_id);
4672 local_table_for_iseq->ids[local_index] = local;
4673
4674 *value = (st_data_t)local_index;
4675
4676 ctx->local_index++;
4677 }
4678
4679 return ST_CONTINUE;
4680}
4681
4687static void
4688pm_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)
4689{
4690 RUBY_ASSERT((constant_id & PM_SPECIAL_CONSTANT_FLAG) == 0);
4691
4692 ID local = pm_constant_id_lookup(scope_node, constant_id);
4693 local_table_for_iseq->ids[local_index] = local;
4694 st_insert(index_lookup_table, (st_data_t) constant_id, (st_data_t) local_index);
4695}
4696
4701static void
4702pm_insert_local_special(ID local_name, int local_index, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq)
4703{
4704 local_table_for_iseq->ids[local_index] = local_name;
4705 st_insert(index_lookup_table, (st_data_t) (local_name | PM_SPECIAL_CONSTANT_FLAG), (st_data_t) local_index);
4706}
4707
4714static int
4715pm_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)
4716{
4717 for (size_t index = 0; index < node->lefts.size; index++) {
4718 const pm_node_t *left = node->lefts.nodes[index];
4719
4720 if (PM_NODE_TYPE_P(left, PM_REQUIRED_PARAMETER_NODE)) {
4721 if (!PM_NODE_FLAG_P(left, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4722 pm_insert_local_index(((const pm_required_parameter_node_t *) left)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4723 local_index++;
4724 }
4725 }
4726 else {
4727 RUBY_ASSERT(PM_NODE_TYPE_P(left, PM_MULTI_TARGET_NODE));
4728 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);
4729 }
4730 }
4731
4732 if (node->rest != NULL && PM_NODE_TYPE_P(node->rest, PM_SPLAT_NODE)) {
4733 const pm_splat_node_t *rest = (const pm_splat_node_t *) node->rest;
4734
4735 if (rest->expression != NULL) {
4736 RUBY_ASSERT(PM_NODE_TYPE_P(rest->expression, PM_REQUIRED_PARAMETER_NODE));
4737
4738 if (!PM_NODE_FLAG_P(rest->expression, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4739 pm_insert_local_index(((const pm_required_parameter_node_t *) rest->expression)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4740 local_index++;
4741 }
4742 }
4743 }
4744
4745 for (size_t index = 0; index < node->rights.size; index++) {
4746 const pm_node_t *right = node->rights.nodes[index];
4747
4748 if (PM_NODE_TYPE_P(right, PM_REQUIRED_PARAMETER_NODE)) {
4749 if (!PM_NODE_FLAG_P(right, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4750 pm_insert_local_index(((const pm_required_parameter_node_t *) right)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4751 local_index++;
4752 }
4753 }
4754 else {
4755 RUBY_ASSERT(PM_NODE_TYPE_P(right, PM_MULTI_TARGET_NODE));
4756 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);
4757 }
4758 }
4759
4760 return local_index;
4761}
4762
4767static inline void
4768pm_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)
4769{
4770 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4771 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, node->name, 0);
4772 PUSH_SETLOCAL(ret, location, index.index, index.level);
4773}
4774
4783static void
4784pm_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)
4785{
4786 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4787 bool has_rest = (node->rest && PM_NODE_TYPE_P(node->rest, PM_SPLAT_NODE) && (((const pm_splat_node_t *) node->rest)->expression) != NULL);
4788 bool has_rights = node->rights.size > 0;
4789
4790 int flag = (has_rest || has_rights) ? 1 : 0;
4791 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->lefts.size), INT2FIX(flag));
4792
4793 for (size_t index = 0; index < node->lefts.size; index++) {
4794 const pm_node_t *left = node->lefts.nodes[index];
4795
4796 if (PM_NODE_TYPE_P(left, PM_REQUIRED_PARAMETER_NODE)) {
4797 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) left, ret, scope_node);
4798 }
4799 else {
4800 RUBY_ASSERT(PM_NODE_TYPE_P(left, PM_MULTI_TARGET_NODE));
4801 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) left, ret, scope_node);
4802 }
4803 }
4804
4805 if (has_rest) {
4806 if (has_rights) {
4807 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->rights.size), INT2FIX(3));
4808 }
4809
4810 const pm_node_t *rest = ((const pm_splat_node_t *) node->rest)->expression;
4811 RUBY_ASSERT(PM_NODE_TYPE_P(rest, PM_REQUIRED_PARAMETER_NODE));
4812
4813 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) rest, ret, scope_node);
4814 }
4815
4816 if (has_rights) {
4817 if (!has_rest) {
4818 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->rights.size), INT2FIX(2));
4819 }
4820
4821 for (size_t index = 0; index < node->rights.size; index++) {
4822 const pm_node_t *right = node->rights.nodes[index];
4823
4824 if (PM_NODE_TYPE_P(right, PM_REQUIRED_PARAMETER_NODE)) {
4825 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) right, ret, scope_node);
4826 }
4827 else {
4828 RUBY_ASSERT(PM_NODE_TYPE_P(right, PM_MULTI_TARGET_NODE));
4829 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) right, ret, scope_node);
4830 }
4831 }
4832 }
4833}
4834
4839 typedef struct pm_multi_target_state_node {
4840 // The pointer to the topn instruction that will need to be modified after
4841 // we know the total stack size of all of the targets.
4842 INSN *topn;
4843
4844 // The index of the stack from the base of the entire multi target at which
4845 // the parent expression is located.
4846 size_t stack_index;
4847
4848 // The number of slots in the stack that this node occupies.
4849 size_t stack_size;
4850
4851 // The position of the node in the list of targets.
4852 size_t position;
4853
4854 // A pointer to the next node in this linked list.
4855 struct pm_multi_target_state_node *next;
4856} pm_multi_target_state_node_t;
4857
4865 typedef struct {
4866 // The total number of slots in the stack that this multi target occupies.
4867 size_t stack_size;
4868
4869 // The position of the current node being compiled. This is forwarded to
4870 // nodes when they are allocated.
4871 size_t position;
4872
4873 // A pointer to the head of this linked list.
4874 pm_multi_target_state_node_t *head;
4875
4876 // A pointer to the tail of this linked list.
4877 pm_multi_target_state_node_t *tail;
4878} pm_multi_target_state_t;
4879
4883static void
4884pm_multi_target_state_push(pm_multi_target_state_t *state, INSN *topn, size_t stack_size)
4885{
4886 pm_multi_target_state_node_t *node = ALLOC(pm_multi_target_state_node_t);
4887 node->topn = topn;
4888 node->stack_index = state->stack_size + 1;
4889 node->stack_size = stack_size;
4890 node->position = state->position;
4891 node->next = NULL;
4892
4893 if (state->head == NULL) {
4894 state->head = node;
4895 state->tail = node;
4896 }
4897 else {
4898 state->tail->next = node;
4899 state->tail = node;
4900 }
4901
4902 state->stack_size += stack_size;
4903}
4904
4910static void
4911pm_multi_target_state_update(pm_multi_target_state_t *state)
4912{
4913 // If nothing was ever pushed onto the stack, then we don't need to do any
4914 // kind of updates.
4915 if (state->stack_size == 0) return;
4916
4917 pm_multi_target_state_node_t *current = state->head;
4918 pm_multi_target_state_node_t *previous;
4919
4920 while (current != NULL) {
4921 VALUE offset = INT2FIX(state->stack_size - current->stack_index + current->position);
4922 current->topn->operands[0] = offset;
4923
4924 // stack_size will be > 1 in the case that we compiled an index target
4925 // and it had arguments. In this case, we use multiple topn instructions
4926 // to grab up all of the arguments as well, so those offsets need to be
4927 // updated as well.
4928 if (current->stack_size > 1) {
4929 INSN *insn = current->topn;
4930
4931 for (size_t index = 1; index < current->stack_size; index += 1) {
4932 LINK_ELEMENT *element = get_next_insn(insn);
4933 RUBY_ASSERT(IS_INSN(element));
4934
4935 insn = (INSN *) element;
4936 RUBY_ASSERT(insn->insn_id == BIN(topn));
4937
4938 insn->operands[0] = offset;
4939 }
4940 }
4941
4942 previous = current;
4943 current = current->next;
4944
4945 xfree(previous);
4946 }
4947}
4948
4949static void
4950pm_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);
4951
4980static void
4981pm_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)
4982{
4983 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4984
4985 switch (PM_NODE_TYPE(node)) {
4986 case PM_LOCAL_VARIABLE_TARGET_NODE: {
4987 // Local variable targets have no parent expression, so they only need
4988 // to compile the write.
4989 //
4990 // for i in []; end
4991 //
4992 const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
4993 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
4994
4995 PUSH_SETLOCAL(writes, location, index.index, index.level);
4996 break;
4997 }
4998 case PM_CLASS_VARIABLE_TARGET_NODE: {
4999 // Class variable targets have no parent expression, so they only need
5000 // to compile the write.
5001 //
5002 // for @@i in []; end
5003 //
5004 const pm_class_variable_target_node_t *cast = (const pm_class_variable_target_node_t *) node;
5005 ID name = pm_constant_id_lookup(scope_node, cast->name);
5006
5007 VALUE operand = ID2SYM(name);
5008 PUSH_INSN2(writes, location, setclassvariable, operand, get_cvar_ic_value(iseq, name));
5009 break;
5010 }
5011 case PM_CONSTANT_TARGET_NODE: {
5012 // Constant targets have no parent expression, so they only need to
5013 // compile the write.
5014 //
5015 // for I in []; end
5016 //
5017 const pm_constant_target_node_t *cast = (const pm_constant_target_node_t *) node;
5018 ID name = pm_constant_id_lookup(scope_node, cast->name);
5019
5020 VALUE operand = ID2SYM(name);
5021 PUSH_INSN1(writes, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5022 PUSH_INSN1(writes, location, setconstant, operand);
5023 break;
5024 }
5025 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
5026 // Global variable targets have no parent expression, so they only need
5027 // to compile the write.
5028 //
5029 // for $i in []; end
5030 //
5031 const pm_global_variable_target_node_t *cast = (const pm_global_variable_target_node_t *) node;
5032 ID name = pm_constant_id_lookup(scope_node, cast->name);
5033
5034 VALUE operand = ID2SYM(name);
5035 PUSH_INSN1(writes, location, setglobal, operand);
5036 break;
5037 }
5038 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
5039 // Instance variable targets have no parent expression, so they only
5040 // need to compile the write.
5041 //
5042 // for @i in []; end
5043 //
5044 const pm_instance_variable_target_node_t *cast = (const pm_instance_variable_target_node_t *) node;
5045 ID name = pm_constant_id_lookup(scope_node, cast->name);
5046
5047 VALUE operand = ID2SYM(name);
5048 PUSH_INSN2(writes, location, setinstancevariable, operand, get_ivar_ic_value(iseq, name));
5049 break;
5050 }
5051 case PM_CONSTANT_PATH_TARGET_NODE: {
5052 // Constant path targets have a parent expression that is the object
5053 // that owns the constant. This needs to be compiled first into the
5054 // parents sequence. If no parent is found, then it represents using the
5055 // unary :: operator to indicate a top-level constant. In that case we
5056 // need to push Object onto the stack.
5057 //
5058 // for I::J in []; end
5059 //
5060 const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
5061 ID name = pm_constant_id_lookup(scope_node, cast->name);
5062
5063 if (cast->parent != NULL) {
5064 pm_compile_node(iseq, cast->parent, parents, false, scope_node);
5065 }
5066 else {
5067 PUSH_INSN1(parents, location, putobject, rb_cObject);
5068 }
5069
5070 if (state == NULL) {
5071 PUSH_INSN(writes, location, swap);
5072 }
5073 else {
5074 PUSH_INSN1(writes, location, topn, INT2FIX(1));
5075 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
5076 }
5077
5078 VALUE operand = ID2SYM(name);
5079 PUSH_INSN1(writes, location, setconstant, operand);
5080
5081 if (state != NULL) {
5082 PUSH_INSN(cleanup, location, pop);
5083 }
5084
5085 break;
5086 }
5087 case PM_CALL_TARGET_NODE: {
5088 // Call targets have a parent expression that is the receiver of the
5089 // method being called. This needs to be compiled first into the parents
5090 // sequence. These nodes cannot have arguments, so the method call is
5091 // compiled with a single argument which represents the value being
5092 // written.
5093 //
5094 // for i.j in []; end
5095 //
5096 const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
5097 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
5098
5099 pm_compile_node(iseq, cast->receiver, parents, false, scope_node);
5100
5101 LABEL *safe_label = NULL;
5102 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5103 safe_label = NEW_LABEL(location.line);
5104 PUSH_INSN(parents, location, dup);
5105 PUSH_INSNL(parents, location, branchnil, safe_label);
5106 }
5107
5108 if (state != NULL) {
5109 PUSH_INSN1(writes, location, topn, INT2FIX(1));
5110 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
5111 PUSH_INSN(writes, location, swap);
5112 }
5113
5114 int flags = VM_CALL_ARGS_SIMPLE;
5115 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) flags |= VM_CALL_FCALL;
5116
5117 PUSH_SEND_WITH_FLAG(writes, location, method_id, INT2FIX(1), INT2FIX(flags));
5118 if (safe_label != NULL && state == NULL) PUSH_LABEL(writes, safe_label);
5119 PUSH_INSN(writes, location, pop);
5120 if (safe_label != NULL && state != NULL) PUSH_LABEL(writes, safe_label);
5121
5122 if (state != NULL) {
5123 PUSH_INSN(cleanup, location, pop);
5124 }
5125
5126 break;
5127 }
5128 case PM_INDEX_TARGET_NODE: {
5129 // Index targets have a parent expression that is the receiver of the
5130 // method being called and any additional arguments that are being
5131 // passed along with the value being written. The receiver and arguments
5132 // both need to be on the stack. Note that this is even more complicated
5133 // by the fact that these nodes can hold a block using the unary &
5134 // operator.
5135 //
5136 // for i[:j] in []; end
5137 //
5138 const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
5139
5140 pm_compile_node(iseq, cast->receiver, parents, false, scope_node);
5141
5142 int flags = 0;
5143 struct rb_callinfo_kwarg *kwargs = NULL;
5144 int argc = pm_setup_args(cast->arguments, (const pm_node_t *) cast->block, &flags, &kwargs, iseq, parents, scope_node, &location);
5145
5146 if (state != NULL) {
5147 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5148 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), argc + 1);
5149
5150 if (argc == 0) {
5151 PUSH_INSN(writes, location, swap);
5152 }
5153 else {
5154 for (int index = 0; index < argc; index++) {
5155 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5156 }
5157 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5158 }
5159 }
5160
5161 // The argc that we're going to pass to the send instruction is the
5162 // number of arguments + 1 for the value being written. If there's a
5163 // splat, then we need to insert newarray and concatarray instructions
5164 // after the arguments have been written.
5165 int ci_argc = argc + 1;
5166 if (flags & VM_CALL_ARGS_SPLAT) {
5167 ci_argc--;
5168 PUSH_INSN1(writes, location, newarray, INT2FIX(1));
5169 PUSH_INSN(writes, location, concatarray);
5170 }
5171
5172 PUSH_SEND_R(writes, location, idASET, INT2NUM(ci_argc), NULL, INT2FIX(flags), kwargs);
5173 PUSH_INSN(writes, location, pop);
5174
5175 if (state != NULL) {
5176 if (argc != 0) {
5177 PUSH_INSN(writes, location, pop);
5178 }
5179
5180 for (int index = 0; index < argc + 1; index++) {
5181 PUSH_INSN(cleanup, location, pop);
5182 }
5183 }
5184
5185 break;
5186 }
5187 case PM_MULTI_TARGET_NODE: {
5188 // Multi target nodes represent a set of writes to multiple variables.
5189 // The parent expressions are the combined set of the parent expressions
5190 // of its inner target nodes.
5191 //
5192 // for i, j in []; end
5193 //
5194 size_t before_position;
5195 if (state != NULL) {
5196 before_position = state->position;
5197 state->position--;
5198 }
5199
5200 pm_compile_multi_target_node(iseq, node, parents, writes, cleanup, scope_node, state);
5201 if (state != NULL) state->position = before_position;
5202
5203 break;
5204 }
5205 case PM_SPLAT_NODE: {
5206 // Splat nodes capture all values into an array. They can be used
5207 // as targets in assignments or for loops.
5208 //
5209 // for *x in []; end
5210 //
5211 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
5212
5213 if (cast->expression != NULL) {
5214 pm_compile_target_node(iseq, cast->expression, parents, writes, cleanup, scope_node, state);
5215 }
5216
5217 break;
5218 }
5219 default:
5220 rb_bug("Unexpected node type: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5221 break;
5222 }
5223}
5224
5230static void
5231pm_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)
5232{
5233 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5234 const pm_node_list_t *lefts;
5235 const pm_node_t *rest;
5236 const pm_node_list_t *rights;
5237
5238 switch (PM_NODE_TYPE(node)) {
5239 case PM_MULTI_TARGET_NODE: {
5240 const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
5241 lefts = &cast->lefts;
5242 rest = cast->rest;
5243 rights = &cast->rights;
5244 break;
5245 }
5246 case PM_MULTI_WRITE_NODE: {
5247 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
5248 lefts = &cast->lefts;
5249 rest = cast->rest;
5250 rights = &cast->rights;
5251 break;
5252 }
5253 default:
5254 rb_bug("Unsupported node %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5255 break;
5256 }
5257
5258 bool has_rest = (rest != NULL) && PM_NODE_TYPE_P(rest, PM_SPLAT_NODE) && ((const pm_splat_node_t *) rest)->expression != NULL;
5259 bool has_posts = rights->size > 0;
5260
5261 // The first instruction in the writes sequence is going to spread the
5262 // top value of the stack onto the number of values that we're going to
5263 // write.
5264 PUSH_INSN2(writes, location, expandarray, INT2FIX(lefts->size), INT2FIX((has_rest || has_posts) ? 1 : 0));
5265
5266 // We need to keep track of some additional state information as we're
5267 // going through the targets because we will need to revisit them once
5268 // we know how many values are being pushed onto the stack.
5269 pm_multi_target_state_t target_state = { 0 };
5270 if (state == NULL) state = &target_state;
5271
5272 size_t base_position = state->position;
5273 size_t splat_position = (has_rest || has_posts) ? 1 : 0;
5274
5275 // Next, we'll iterate through all of the leading targets.
5276 for (size_t index = 0; index < lefts->size; index++) {
5277 const pm_node_t *target = lefts->nodes[index];
5278 state->position = lefts->size - index + splat_position + base_position;
5279 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5280 }
5281
5282 // Next, we'll compile the rest target if there is one.
5283 if (has_rest) {
5284 const pm_node_t *target = ((const pm_splat_node_t *) rest)->expression;
5285 state->position = 1 + rights->size + base_position;
5286
5287 if (has_posts) {
5288 PUSH_INSN2(writes, location, expandarray, INT2FIX(rights->size), INT2FIX(3));
5289 }
5290
5291 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5292 }
5293
5294 // Finally, we'll compile the trailing targets.
5295 if (has_posts) {
5296 if (!has_rest && rest != NULL) {
5297 PUSH_INSN2(writes, location, expandarray, INT2FIX(rights->size), INT2FIX(2));
5298 }
5299
5300 for (size_t index = 0; index < rights->size; index++) {
5301 const pm_node_t *target = rights->nodes[index];
5302 state->position = rights->size - index + base_position;
5303 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5304 }
5305 }
5306}
5307
5313static void
5314pm_compile_for_node_index(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node)
5315{
5316 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5317
5318 switch (PM_NODE_TYPE(node)) {
5319 case PM_LOCAL_VARIABLE_TARGET_NODE: {
5320 // For local variables, all we have to do is retrieve the value and then
5321 // compile the index node.
5322 PUSH_GETLOCAL(ret, location, 1, 0);
5323 pm_compile_target_node(iseq, node, ret, ret, ret, scope_node, NULL);
5324 break;
5325 }
5326 case PM_CLASS_VARIABLE_TARGET_NODE:
5327 case PM_CONSTANT_TARGET_NODE:
5328 case PM_GLOBAL_VARIABLE_TARGET_NODE:
5329 case PM_INSTANCE_VARIABLE_TARGET_NODE:
5330 case PM_CONSTANT_PATH_TARGET_NODE:
5331 case PM_CALL_TARGET_NODE:
5332 case PM_INDEX_TARGET_NODE: {
5333 // For other targets, we need to potentially compile the parent or
5334 // owning expression of this target, then retrieve the value, expand it,
5335 // and then compile the necessary writes.
5336 DECL_ANCHOR(writes);
5337 DECL_ANCHOR(cleanup);
5338
5339 pm_multi_target_state_t state = { 0 };
5340 state.position = 1;
5341 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
5342
5343 PUSH_GETLOCAL(ret, location, 1, 0);
5344 PUSH_INSN2(ret, location, expandarray, INT2FIX(1), INT2FIX(0));
5345
5346 PUSH_SEQ(ret, writes);
5347 PUSH_SEQ(ret, cleanup);
5348
5349 pm_multi_target_state_update(&state);
5350 break;
5351 }
5352 case PM_SPLAT_NODE:
5353 case PM_MULTI_TARGET_NODE: {
5354 DECL_ANCHOR(writes);
5355 DECL_ANCHOR(cleanup);
5356
5357 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, NULL);
5358
5359 LABEL *not_single = NEW_LABEL(location.line);
5360 LABEL *not_ary = NEW_LABEL(location.line);
5361
5362 // When there are multiple targets, we'll do a bunch of work to convert
5363 // the value into an array before we expand it. Effectively we're trying
5364 // to accomplish:
5365 //
5366 // (args.length == 1 && Array.try_convert(args[0])) || args
5367 //
5368 PUSH_GETLOCAL(ret, location, 1, 0);
5369 PUSH_INSN(ret, location, dup);
5370 PUSH_CALL(ret, location, idLength, INT2FIX(0));
5371 PUSH_INSN1(ret, location, putobject, INT2FIX(1));
5372 PUSH_CALL(ret, location, idEq, INT2FIX(1));
5373 PUSH_INSNL(ret, location, branchunless, not_single);
5374 PUSH_INSN(ret, location, dup);
5375 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
5376 PUSH_CALL(ret, location, idAREF, INT2FIX(1));
5377 PUSH_INSN1(ret, location, putobject, rb_cArray);
5378 PUSH_INSN(ret, location, swap);
5379 PUSH_CALL(ret, location, rb_intern("try_convert"), INT2FIX(1));
5380 PUSH_INSN(ret, location, dup);
5381 PUSH_INSNL(ret, location, branchunless, not_ary);
5382 PUSH_INSN(ret, location, swap);
5383
5384 PUSH_LABEL(ret, not_ary);
5385 PUSH_INSN(ret, location, pop);
5386
5387 PUSH_LABEL(ret, not_single);
5388
5389 if (PM_NODE_TYPE_P(node, PM_SPLAT_NODE)) {
5390 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
5391 PUSH_INSN2(ret, location, expandarray, INT2FIX(0), INT2FIX(cast->expression == NULL ? 0 : 1));
5392 }
5393
5394 PUSH_SEQ(ret, writes);
5395 PUSH_SEQ(ret, cleanup);
5396 break;
5397 }
5398 default:
5399 rb_bug("Unexpected node type for index in for node: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5400 break;
5401 }
5402}
5403
5404static void
5405pm_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)
5406{
5407 const pm_parser_t *parser = scope_node->parser;
5408
5409 LABEL *lstart = NEW_LABEL(node_location->line);
5410 LABEL *lend = NEW_LABEL(node_location->line);
5411 LABEL *lcont = NEW_LABEL(node_location->line);
5412
5413 pm_scope_node_t rescue_scope_node;
5414 pm_scope_node_init((const pm_node_t *) cast->rescue_clause, &rescue_scope_node, scope_node);
5415
5416 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
5417 &rescue_scope_node,
5418 rb_str_concat(rb_str_new2("rescue in "), ISEQ_BODY(iseq)->location.label),
5419 ISEQ_TYPE_RESCUE,
5420 pm_node_line_number(parser, (const pm_node_t *) cast->rescue_clause)
5421 );
5422
5423 pm_scope_node_destroy(&rescue_scope_node);
5424
5425 lstart->rescued = LABEL_RESCUE_BEG;
5426 lend->rescued = LABEL_RESCUE_END;
5427 PUSH_LABEL(ret, lstart);
5428
5429 bool prev_in_rescue = ISEQ_COMPILE_DATA(iseq)->in_rescue;
5430 ISEQ_COMPILE_DATA(iseq)->in_rescue = true;
5431
5432 if (cast->statements != NULL) {
5433 PM_COMPILE_NOT_POPPED((const pm_node_t *) cast->statements);
5434 }
5435 else {
5436 const pm_node_location_t location = PM_NODE_START_LOCATION(parser, cast->rescue_clause);
5437 PUSH_INSN(ret, location, putnil);
5438 }
5439
5440 ISEQ_COMPILE_DATA(iseq)->in_rescue = prev_in_rescue;
5441 PUSH_LABEL(ret, lend);
5442
5443 if (cast->else_clause != NULL) {
5444 if (!popped) PUSH_INSN(ret, *node_location, pop);
5445 PM_COMPILE((const pm_node_t *) cast->else_clause);
5446 }
5447
5448 PUSH_INSN(ret, *node_location, nop);
5449 PUSH_LABEL(ret, lcont);
5450
5451 if (popped) PUSH_INSN(ret, *node_location, pop);
5452 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
5453 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
5454}
5455
5456static void
5457pm_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)
5458{
5459 const pm_parser_t *parser = scope_node->parser;
5460 const pm_statements_node_t *statements = cast->ensure_clause->statements;
5461
5462 pm_node_location_t location;
5463 if (statements != NULL) {
5464 location = PM_NODE_START_LOCATION(parser, statements);
5465 }
5466 else {
5467 location = *node_location;
5468 }
5469
5470 LABEL *lstart = NEW_LABEL(location.line);
5471 LABEL *lend = NEW_LABEL(location.line);
5472 LABEL *lcont = NEW_LABEL(location.line);
5473
5474 struct ensure_range er;
5475 struct iseq_compile_data_ensure_node_stack enl;
5476 struct ensure_range *erange;
5477
5478 DECL_ANCHOR(ensr);
5479 if (statements != NULL) {
5480 pm_compile_node(iseq, (const pm_node_t *) statements, ensr, true, scope_node);
5481 }
5482
5483 LINK_ELEMENT *last = ensr->last;
5484 bool last_leave = last && IS_INSN(last) && IS_INSN_ID(last, leave);
5485
5486 er.begin = lstart;
5487 er.end = lend;
5488 er.next = 0;
5489 push_ensure_entry(iseq, &enl, &er, (void *) cast->ensure_clause);
5490
5491 PUSH_LABEL(ret, lstart);
5492 if (cast->rescue_clause != NULL) {
5493 pm_compile_rescue(iseq, cast, node_location, ret, popped | last_leave, scope_node);
5494 }
5495 else if (cast->statements != NULL) {
5496 pm_compile_node(iseq, (const pm_node_t *) cast->statements, ret, popped | last_leave, scope_node);
5497 }
5498 else if (!(popped | last_leave)) {
5499 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
5500 }
5501
5502 PUSH_LABEL(ret, lend);
5503 PUSH_SEQ(ret, ensr);
5504 if (!popped && last_leave) PUSH_INSN(ret, *node_location, putnil);
5505 PUSH_LABEL(ret, lcont);
5506 if (last_leave) PUSH_INSN(ret, *node_location, pop);
5507
5508 pm_scope_node_t next_scope_node;
5509 pm_scope_node_init((const pm_node_t *) cast->ensure_clause, &next_scope_node, scope_node);
5510
5511 rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(
5512 &next_scope_node,
5513 rb_str_concat(rb_str_new2("ensure in "), ISEQ_BODY(iseq)->location.label),
5514 ISEQ_TYPE_ENSURE,
5515 location.line
5516 );
5517
5518 pm_scope_node_destroy(&next_scope_node);
5519
5520 erange = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->erange;
5521 if (lstart->link.next != &lend->link) {
5522 while (erange) {
5523 PUSH_CATCH_ENTRY(CATCH_TYPE_ENSURE, erange->begin, erange->end, child_iseq, lcont);
5524 erange = erange->next;
5525 }
5526 }
5527 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enl.prev;
5528}
5529
5534static inline bool
5535pm_opt_str_freeze_p(const rb_iseq_t *iseq, const pm_call_node_t *node)
5536{
5537 return (
5538 !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) &&
5539 node->receiver != NULL &&
5540 PM_NODE_TYPE_P(node->receiver, PM_STRING_NODE) &&
5541 node->arguments == NULL &&
5542 node->block == NULL &&
5543 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5544 );
5545}
5546
5551static void
5552pm_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)
5553{
5554 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, name_loc, node_id);
5555
5556 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache) {
5557 ISEQ_BODY(iseq)->ic_size++;
5558 VALUE segments = rb_ary_new_from_args(1, name);
5559 RB_OBJ_SET_SHAREABLE(segments);
5560 PUSH_INSN1(ret, location, opt_getconstant_path, segments);
5561 }
5562 else {
5563 PUSH_INSN(ret, location, putnil);
5564 PUSH_INSN1(ret, location, putobject, Qtrue);
5565 PUSH_INSN1(ret, location, getconstant, name);
5566 }
5567}
5568
5573static VALUE
5574pm_constant_path_parts(const pm_node_t *node, const pm_scope_node_t *scope_node)
5575{
5576 VALUE parts = rb_ary_new();
5577
5578 while (true) {
5579 switch (PM_NODE_TYPE(node)) {
5580 case PM_CONSTANT_READ_NODE: {
5581 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
5582 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5583
5584 rb_ary_unshift(parts, name);
5585 return parts;
5586 }
5587 case PM_CONSTANT_PATH_NODE: {
5588 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
5589 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5590
5591 rb_ary_unshift(parts, name);
5592 if (cast->parent == NULL) {
5593 rb_ary_unshift(parts, ID2SYM(idNULL));
5594 return parts;
5595 }
5596
5597 node = cast->parent;
5598 break;
5599 }
5600 default:
5601 return Qnil;
5602 }
5603 }
5604}
5605
5611static void
5612pm_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)
5613{
5614 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5615
5616 switch (PM_NODE_TYPE(node)) {
5617 case PM_CONSTANT_READ_NODE: {
5618 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
5619 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5620
5621 PUSH_INSN1(body, location, putobject, Qtrue);
5622 PUSH_INSN1(body, location, getconstant, name);
5623 break;
5624 }
5625 case PM_CONSTANT_PATH_NODE: {
5626 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
5627 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5628
5629 if (cast->parent == NULL) {
5630 PUSH_INSN(body, location, pop);
5631 PUSH_INSN1(body, location, putobject, rb_cObject);
5632 PUSH_INSN1(body, location, putobject, Qtrue);
5633 PUSH_INSN1(body, location, getconstant, name);
5634 }
5635 else {
5636 pm_compile_constant_path(iseq, cast->parent, prefix, body, false, scope_node);
5637 PUSH_INSN1(body, location, putobject, Qfalse);
5638 PUSH_INSN1(body, location, getconstant, name);
5639 }
5640 break;
5641 }
5642 default:
5643 PM_COMPILE_INTO_ANCHOR(prefix, node);
5644 break;
5645 }
5646}
5647
5651static VALUE
5652pm_compile_shareable_constant_literal(rb_iseq_t *iseq, const pm_node_t *node, const pm_scope_node_t *scope_node)
5653{
5654 switch (PM_NODE_TYPE(node)) {
5655 case PM_TRUE_NODE:
5656 case PM_FALSE_NODE:
5657 case PM_NIL_NODE:
5658 case PM_SYMBOL_NODE:
5659 case PM_REGULAR_EXPRESSION_NODE:
5660 case PM_SOURCE_LINE_NODE:
5661 case PM_INTEGER_NODE:
5662 case PM_FLOAT_NODE:
5663 case PM_RATIONAL_NODE:
5664 case PM_IMAGINARY_NODE:
5665 case PM_SOURCE_ENCODING_NODE:
5666 return pm_static_literal_value(iseq, node, scope_node);
5667 case PM_STRING_NODE:
5668 return parse_static_literal_string(iseq, scope_node, node, &((const pm_string_node_t *) node)->unescaped);
5669 case PM_SOURCE_FILE_NODE:
5670 return pm_source_file_value((const pm_source_file_node_t *) node, scope_node);
5671 case PM_ARRAY_NODE: {
5672 const pm_array_node_t *cast = (const pm_array_node_t *) node;
5673 VALUE result = rb_ary_new_capa(cast->elements.size);
5674
5675 for (size_t index = 0; index < cast->elements.size; index++) {
5676 VALUE element = pm_compile_shareable_constant_literal(iseq, cast->elements.nodes[index], scope_node);
5677 if (element == Qundef) return Qundef;
5678
5679 rb_ary_push(result, element);
5680 }
5681
5682 return rb_ractor_make_shareable(result);
5683 }
5684 case PM_HASH_NODE: {
5685 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
5686 VALUE result = rb_hash_new_capa(cast->elements.size);
5687
5688 for (size_t index = 0; index < cast->elements.size; index++) {
5689 const pm_node_t *element = cast->elements.nodes[index];
5690 if (!PM_NODE_TYPE_P(element, PM_ASSOC_NODE)) return Qundef;
5691
5692 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
5693
5694 VALUE key = pm_compile_shareable_constant_literal(iseq, assoc->key, scope_node);
5695 if (key == Qundef) return Qundef;
5696
5697 VALUE value = pm_compile_shareable_constant_literal(iseq, assoc->value, scope_node);
5698 if (value == Qundef) return Qundef;
5699
5700 rb_hash_aset(result, key, value);
5701 }
5702
5703 return rb_ractor_make_shareable(result);
5704 }
5705 default:
5706 return Qundef;
5707 }
5708}
5709
5714static void
5715pm_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)
5716{
5717 VALUE literal = pm_compile_shareable_constant_literal(iseq, node, scope_node);
5718 if (literal != Qundef) {
5719 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5720 PUSH_INSN1(ret, location, putobject, literal);
5721 return;
5722 }
5723
5724 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5725 switch (PM_NODE_TYPE(node)) {
5726 case PM_ARRAY_NODE: {
5727 const pm_array_node_t *cast = (const pm_array_node_t *) node;
5728
5729 if (top) {
5730 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5731 }
5732
5733 for (size_t index = 0; index < cast->elements.size; index++) {
5734 pm_compile_shareable_constant_value(iseq, cast->elements.nodes[index], shareability, path, ret, scope_node, false);
5735 }
5736
5737 PUSH_INSN1(ret, location, newarray, INT2FIX(cast->elements.size));
5738
5739 if (top) {
5740 ID method_id = (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) ? rb_intern("make_shareable_copy") : rb_intern("make_shareable");
5741 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5742 }
5743
5744 return;
5745 }
5746 case PM_HASH_NODE: {
5747 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
5748
5749 if (top) {
5750 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5751 }
5752
5753 pm_compile_hash_elements(iseq, (const pm_node_t *) cast, &cast->elements, shareability, path, false, ret, scope_node);
5754
5755 if (top) {
5756 ID method_id = (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) ? rb_intern("make_shareable_copy") : rb_intern("make_shareable");
5757 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5758 }
5759
5760 return;
5761 }
5762 default: {
5763 DECL_ANCHOR(value_seq);
5764
5765 pm_compile_node(iseq, node, value_seq, false, scope_node);
5766 if (PM_NODE_TYPE_P(node, PM_INTERPOLATED_STRING_NODE)) {
5767 PUSH_SEND_WITH_FLAG(value_seq, location, idUMinus, INT2FIX(0), INT2FIX(VM_CALL_ARGS_SIMPLE));
5768 }
5769
5770 if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL) {
5771 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5772 PUSH_SEQ(ret, value_seq);
5773 if (!RB_OBJ_SHAREABLE_P(path)) {
5774 RB_OBJ_SET_SHAREABLE(path);
5775 }
5776 PUSH_INSN1(ret, location, putobject, path);
5777 PUSH_SEND_WITH_FLAG(ret, location, rb_intern("ensure_shareable"), INT2FIX(2), INT2FIX(VM_CALL_ARGS_SIMPLE));
5778 }
5779 else if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) {
5780 if (top) PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5781 PUSH_SEQ(ret, value_seq);
5782 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern("make_shareable_copy"), INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5783 }
5784 else if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING) {
5785 if (top) PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5786 PUSH_SEQ(ret, value_seq);
5787 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern("make_shareable"), INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5788 }
5789
5790 break;
5791 }
5792 }
5793}
5794
5799static void
5800pm_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)
5801{
5802 const pm_node_location_t location = *node_location;
5803 ID name_id = pm_constant_id_lookup(scope_node, node->name);
5804
5805 if (shareability != 0) {
5806 pm_compile_shareable_constant_value(iseq, node->value, shareability, rb_id2str(name_id), ret, scope_node, true);
5807 }
5808 else {
5809 PM_COMPILE_NOT_POPPED(node->value);
5810 }
5811
5812 if (!popped) PUSH_INSN(ret, location, dup);
5813 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5814
5815 VALUE operand = ID2SYM(name_id);
5816 PUSH_INSN1(ret, location, setconstant, operand);
5817}
5818
5823static void
5824pm_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)
5825{
5826 const pm_node_location_t location = *node_location;
5827
5828 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5829 LABEL *end_label = NEW_LABEL(location.line);
5830
5831 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5832 if (!popped) PUSH_INSN(ret, location, dup);
5833
5834 PUSH_INSNL(ret, location, branchunless, end_label);
5835 if (!popped) PUSH_INSN(ret, location, pop);
5836
5837 if (shareability != 0) {
5838 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5839 }
5840 else {
5841 PM_COMPILE_NOT_POPPED(node->value);
5842 }
5843
5844 if (!popped) PUSH_INSN(ret, location, dup);
5845 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5846 PUSH_INSN1(ret, location, setconstant, name);
5847 PUSH_LABEL(ret, end_label);
5848}
5849
5854static void
5855pm_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)
5856{
5857 const pm_node_location_t location = *node_location;
5858 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5859
5860 LABEL *set_label = NEW_LABEL(location.line);
5861 LABEL *end_label = NEW_LABEL(location.line);
5862
5863 PUSH_INSN(ret, location, putnil);
5864 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST), name, Qtrue);
5865 PUSH_INSNL(ret, location, branchunless, set_label);
5866
5867 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5868 if (!popped) PUSH_INSN(ret, location, dup);
5869
5870 PUSH_INSNL(ret, location, branchif, end_label);
5871 if (!popped) PUSH_INSN(ret, location, pop);
5872 PUSH_LABEL(ret, set_label);
5873
5874 if (shareability != 0) {
5875 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5876 }
5877 else {
5878 PM_COMPILE_NOT_POPPED(node->value);
5879 }
5880
5881 if (!popped) PUSH_INSN(ret, location, dup);
5882 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5883 PUSH_INSN1(ret, location, setconstant, name);
5884 PUSH_LABEL(ret, end_label);
5885}
5886
5891static void
5892pm_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)
5893{
5894 const pm_node_location_t location = *node_location;
5895
5896 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5897 ID method_id = pm_constant_id_lookup(scope_node, node->binary_operator);
5898
5899 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5900
5901 if (shareability != 0) {
5902 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5903 }
5904 else {
5905 PM_COMPILE_NOT_POPPED(node->value);
5906 }
5907
5908 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5909 if (!popped) PUSH_INSN(ret, location, dup);
5910
5911 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5912 PUSH_INSN1(ret, location, setconstant, name);
5913}
5914
5919static VALUE
5920pm_constant_path_path(const pm_constant_path_node_t *node, const pm_scope_node_t *scope_node)
5921{
5922 VALUE parts = rb_ary_new();
5923 rb_ary_push(parts, rb_id2str(pm_constant_id_lookup(scope_node, node->name)));
5924
5925 const pm_node_t *current = node->parent;
5926 while (current != NULL && PM_NODE_TYPE_P(current, PM_CONSTANT_PATH_NODE)) {
5927 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) current;
5928 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, cast->name)));
5929 current = cast->parent;
5930 }
5931
5932 if (current == NULL) {
5933 rb_ary_unshift(parts, rb_id2str(idNULL));
5934 }
5935 else if (PM_NODE_TYPE_P(current, PM_CONSTANT_READ_NODE)) {
5936 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, ((const pm_constant_read_node_t *) current)->name)));
5937 }
5938 else {
5939 rb_ary_unshift(parts, rb_str_new_cstr("..."));
5940 }
5941
5942 return rb_ary_join(parts, rb_str_new_cstr("::"));
5943}
5944
5949static void
5950pm_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)
5951{
5952 const pm_node_location_t location = *node_location;
5953 const pm_constant_path_node_t *target = node->target;
5954 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5955
5956 if (target->parent) {
5957 PM_COMPILE_NOT_POPPED((const pm_node_t *) target->parent);
5958 }
5959 else {
5960 PUSH_INSN1(ret, location, putobject, rb_cObject);
5961 }
5962
5963 if (shareability != 0) {
5964 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
5965 }
5966 else {
5967 PM_COMPILE_NOT_POPPED(node->value);
5968 }
5969
5970 if (!popped) {
5971 PUSH_INSN(ret, location, swap);
5972 PUSH_INSN1(ret, location, topn, INT2FIX(1));
5973 }
5974
5975 PUSH_INSN(ret, location, swap);
5976 PUSH_INSN1(ret, location, setconstant, name);
5977}
5978
5983static void
5984pm_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)
5985{
5986 const pm_node_location_t location = *node_location;
5987 const pm_constant_path_node_t *target = node->target;
5988
5989 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5990 LABEL *lfin = NEW_LABEL(location.line);
5991
5992 if (target->parent) {
5993 PM_COMPILE_NOT_POPPED(target->parent);
5994 }
5995 else {
5996 PUSH_INSN1(ret, location, putobject, rb_cObject);
5997 }
5998
5999 PUSH_INSN(ret, location, dup);
6000 PUSH_INSN1(ret, location, putobject, Qtrue);
6001 PUSH_INSN1(ret, location, getconstant, name);
6002
6003 if (!popped) PUSH_INSN(ret, location, dup);
6004 PUSH_INSNL(ret, location, branchunless, lfin);
6005
6006 if (!popped) PUSH_INSN(ret, location, pop);
6007
6008 if (shareability != 0) {
6009 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
6010 }
6011 else {
6012 PM_COMPILE_NOT_POPPED(node->value);
6013 }
6014
6015 if (popped) {
6016 PUSH_INSN1(ret, location, topn, INT2FIX(1));
6017 }
6018 else {
6019 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
6020 PUSH_INSN(ret, location, swap);
6021 }
6022
6023 PUSH_INSN1(ret, location, setconstant, name);
6024 PUSH_LABEL(ret, lfin);
6025
6026 if (!popped) PUSH_INSN(ret, location, swap);
6027 PUSH_INSN(ret, location, pop);
6028}
6029
6034static void
6035pm_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)
6036{
6037 const pm_node_location_t location = *node_location;
6038 const pm_constant_path_node_t *target = node->target;
6039
6040 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
6041 LABEL *lassign = NEW_LABEL(location.line);
6042 LABEL *lfin = NEW_LABEL(location.line);
6043
6044 if (target->parent) {
6045 PM_COMPILE_NOT_POPPED(target->parent);
6046 }
6047 else {
6048 PUSH_INSN1(ret, location, putobject, rb_cObject);
6049 }
6050
6051 PUSH_INSN(ret, location, dup);
6052 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST_FROM), name, Qtrue);
6053 PUSH_INSNL(ret, location, branchunless, lassign);
6054
6055 PUSH_INSN(ret, location, dup);
6056 PUSH_INSN1(ret, location, putobject, Qtrue);
6057 PUSH_INSN1(ret, location, getconstant, name);
6058
6059 if (!popped) PUSH_INSN(ret, location, dup);
6060 PUSH_INSNL(ret, location, branchif, lfin);
6061
6062 if (!popped) PUSH_INSN(ret, location, pop);
6063 PUSH_LABEL(ret, lassign);
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 if (popped) {
6073 PUSH_INSN1(ret, location, topn, INT2FIX(1));
6074 }
6075 else {
6076 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
6077 PUSH_INSN(ret, location, swap);
6078 }
6079
6080 PUSH_INSN1(ret, location, setconstant, name);
6081 PUSH_LABEL(ret, lfin);
6082
6083 if (!popped) PUSH_INSN(ret, location, swap);
6084 PUSH_INSN(ret, location, pop);
6085}
6086
6091static void
6092pm_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)
6093{
6094 const pm_node_location_t location = *node_location;
6095 const pm_constant_path_node_t *target = node->target;
6096
6097 ID method_id = pm_constant_id_lookup(scope_node, node->binary_operator);
6098 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
6099
6100 if (target->parent) {
6101 PM_COMPILE_NOT_POPPED(target->parent);
6102 }
6103 else {
6104 PUSH_INSN1(ret, location, putobject, rb_cObject);
6105 }
6106
6107 PUSH_INSN(ret, location, dup);
6108 PUSH_INSN1(ret, location, putobject, Qtrue);
6109 PUSH_INSN1(ret, location, getconstant, name);
6110
6111 if (shareability != 0) {
6112 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
6113 }
6114 else {
6115 PM_COMPILE_NOT_POPPED(node->value);
6116 }
6117
6118 PUSH_CALL(ret, location, method_id, INT2FIX(1));
6119 PUSH_INSN(ret, location, swap);
6120
6121 if (!popped) {
6122 PUSH_INSN1(ret, location, topn, INT2FIX(1));
6123 PUSH_INSN(ret, location, swap);
6124 }
6125
6126 PUSH_INSN1(ret, location, setconstant, name);
6127}
6128
6135#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))
6136
6141static inline void
6142pm_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)
6143{
6144 const pm_node_location_t location = *node_location;
6145 struct rb_iseq_constant_body *body = ISEQ_BODY(iseq);
6146
6147 pm_constant_id_list_t *locals = &scope_node->locals;
6148 pm_parameters_node_t *parameters_node = NULL;
6149 pm_node_list_t *keywords_list = NULL;
6150 pm_node_list_t *optionals_list = NULL;
6151 pm_node_list_t *posts_list = NULL;
6152 pm_node_list_t *requireds_list = NULL;
6153 pm_node_list_t *block_locals = NULL;
6154 bool trailing_comma = false;
6155
6156 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE) || PM_NODE_TYPE_P(scope_node->ast_node, PM_MODULE_NODE)) {
6157 PUSH_TRACE(ret, RUBY_EVENT_CLASS);
6158 }
6159
6160 if (scope_node->parameters != NULL) {
6161 switch (PM_NODE_TYPE(scope_node->parameters)) {
6162 case PM_BLOCK_PARAMETERS_NODE: {
6163 pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) scope_node->parameters;
6164 parameters_node = cast->parameters;
6165 block_locals = &cast->locals;
6166
6167 if (parameters_node) {
6168 if (parameters_node->rest && PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE)) {
6169 trailing_comma = true;
6170 }
6171 }
6172 break;
6173 }
6174 case PM_PARAMETERS_NODE: {
6175 parameters_node = (pm_parameters_node_t *) scope_node->parameters;
6176 break;
6177 }
6178 case PM_NUMBERED_PARAMETERS_NODE: {
6179 uint32_t maximum = ((const pm_numbered_parameters_node_t *) scope_node->parameters)->maximum;
6180 body->param.lead_num = maximum;
6181 body->param.flags.ambiguous_param0 = maximum == 1;
6182 break;
6183 }
6184 case PM_IT_PARAMETERS_NODE:
6185 body->param.lead_num = 1;
6186 body->param.flags.ambiguous_param0 = true;
6187 break;
6188 default:
6189 rb_bug("Unexpected node type for parameters: %s", pm_node_type_to_str(PM_NODE_TYPE(scope_node->parameters)));
6190 }
6191 }
6192
6193 struct rb_iseq_param_keyword *keyword = NULL;
6194
6195 if (parameters_node) {
6196 optionals_list = &parameters_node->optionals;
6197 requireds_list = &parameters_node->requireds;
6198 keywords_list = &parameters_node->keywords;
6199 posts_list = &parameters_node->posts;
6200 }
6201 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))) {
6202 body->param.opt_num = 0;
6203 }
6204 else {
6205 body->param.lead_num = 0;
6206 body->param.opt_num = 0;
6207 }
6208
6209 //********STEP 1**********
6210 // Goal: calculate the table size for the locals, accounting for
6211 // hidden variables and multi target nodes
6212 size_t locals_size = locals->size;
6213
6214 // Index lookup table buffer size is only the number of the locals
6215 st_table *index_lookup_table = st_init_numtable();
6216
6217 int table_size = (int) locals_size;
6218
6219 // For nodes have a hidden iteration variable. We add that to the local
6220 // table size here.
6221 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) table_size++;
6222
6223 if (keywords_list && keywords_list->size) {
6224 table_size++;
6225 }
6226
6227 if (requireds_list) {
6228 for (size_t i = 0; i < requireds_list->size; i++) {
6229 // For each MultiTargetNode, we're going to have one
6230 // additional anonymous local not represented in the locals table
6231 // We want to account for this in our table size
6232 pm_node_t *required = requireds_list->nodes[i];
6233 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6234 table_size++;
6235 }
6236 else if (PM_NODE_TYPE_P(required, PM_REQUIRED_PARAMETER_NODE)) {
6237 if (PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6238 table_size++;
6239 }
6240 }
6241 }
6242 }
6243
6244 // If we have the `it` implicit local variable, we need to account for
6245 // it in the local table size.
6246 if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
6247 table_size++;
6248 }
6249
6250 // Ensure there is enough room in the local table for any
6251 // parameters that have been repeated
6252 // ex: def underscore_parameters(_, _ = 1, _ = 2); _; end
6253 // ^^^^^^^^^^^^
6254 if (optionals_list && optionals_list->size) {
6255 for (size_t i = 0; i < optionals_list->size; i++) {
6256 pm_node_t * node = optionals_list->nodes[i];
6257 if (PM_NODE_FLAG_P(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6258 table_size++;
6259 }
6260 }
6261 }
6262
6263 // If we have an anonymous "rest" node, we'll need to increase the local
6264 // table size to take it in to account.
6265 // def m(foo, *, bar)
6266 // ^
6267 if (parameters_node) {
6268 if (parameters_node->rest) {
6269 if (!(PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE))) {
6270 if (!((const pm_rest_parameter_node_t *) parameters_node->rest)->name || PM_NODE_FLAG_P(parameters_node->rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6271 table_size++;
6272 }
6273 }
6274 }
6275
6276 // def foo(_, **_); _; end
6277 // ^^^
6278 if (parameters_node->keyword_rest) {
6279 // def foo(...); end
6280 // ^^^
6281 // When we have a `...` as the keyword_rest, it's a forwarding_parameter_node and
6282 // we need to leave space for 4 locals: *, **, &, ...
6283 if (PM_NODE_TYPE_P(parameters_node->keyword_rest, PM_FORWARDING_PARAMETER_NODE)) {
6284 // Only optimize specifically methods like this: `foo(...)`
6285 if (requireds_list->size == 0 && optionals_list->size == 0 && keywords_list->size == 0) {
6286 ISEQ_BODY(iseq)->param.flags.use_block = TRUE;
6287 ISEQ_BODY(iseq)->param.flags.forwardable = TRUE;
6288 table_size += 1;
6289 }
6290 else {
6291 table_size += 4;
6292 }
6293 }
6294 else {
6295 const pm_keyword_rest_parameter_node_t *kw_rest = (const pm_keyword_rest_parameter_node_t *) parameters_node->keyword_rest;
6296
6297 // If it's anonymous or repeated, then we need to allocate stack space
6298 if (!kw_rest->name || PM_NODE_FLAG_P(kw_rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6299 table_size++;
6300 }
6301 }
6302 }
6303 }
6304
6305 if (posts_list) {
6306 for (size_t i = 0; i < posts_list->size; i++) {
6307 // For each MultiTargetNode, we're going to have one
6308 // additional anonymous local not represented in the locals table
6309 // We want to account for this in our table size
6310 pm_node_t *required = posts_list->nodes[i];
6311 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE) || PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6312 table_size++;
6313 }
6314 }
6315 }
6316
6317 if (keywords_list && keywords_list->size) {
6318 for (size_t i = 0; i < keywords_list->size; i++) {
6319 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6320 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6321 table_size++;
6322 }
6323 }
6324 }
6325
6326 if (parameters_node && parameters_node->block) {
6327 const pm_block_parameter_node_t *block_node = (const pm_block_parameter_node_t *) parameters_node->block;
6328
6329 if (PM_NODE_FLAG_P(block_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER) || !block_node->name) {
6330 table_size++;
6331 }
6332 }
6333
6334 // We can create local_table_for_iseq with the correct size
6335 VALUE idtmp = 0;
6336 rb_ast_id_table_t *local_table_for_iseq = ALLOCV(idtmp, sizeof(rb_ast_id_table_t) + table_size * sizeof(ID));
6337 local_table_for_iseq->size = table_size;
6338
6339 //********END OF STEP 1**********
6340
6341 //********STEP 2**********
6342 // Goal: populate iv index table as well as local table, keeping the
6343 // layout of the local table consistent with the layout of the
6344 // stack when calling the method
6345 //
6346 // Do a first pass on all of the parameters, setting their values in
6347 // the local_table_for_iseq, _except_ for Multis who get a hidden
6348 // variable in this step, and will get their names inserted in step 3
6349
6350 // local_index is a cursor that keeps track of the current
6351 // index into local_table_for_iseq. The local table is actually a list,
6352 // and the order of that list must match the order of the items pushed
6353 // on the stack. We need to take in to account things pushed on the
6354 // stack that _might not have a name_ (for example array destructuring).
6355 // This index helps us know which item we're dealing with and also give
6356 // those anonymous items temporary names (as below)
6357 int local_index = 0;
6358
6359 // Here we figure out local table indices and insert them in to the
6360 // index lookup table and local tables.
6361 //
6362 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6363 // ^^^^^^^^^^^^^
6364 if (requireds_list && requireds_list->size) {
6365 for (size_t i = 0; i < requireds_list->size; i++, local_index++) {
6366 ID local;
6367
6368 // For each MultiTargetNode, we're going to have one additional
6369 // anonymous local not represented in the locals table. We want
6370 // to account for this in our table size.
6371 pm_node_t *required = requireds_list->nodes[i];
6372
6373 switch (PM_NODE_TYPE(required)) {
6374 case PM_MULTI_TARGET_NODE: {
6375 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6376 // ^^^^^^^^^^
6377 local = rb_make_temporary_id(local_index);
6378 local_table_for_iseq->ids[local_index] = local;
6379 break;
6380 }
6381 case PM_REQUIRED_PARAMETER_NODE: {
6382 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6383 // ^
6384 const pm_required_parameter_node_t *param = (const pm_required_parameter_node_t *) required;
6385
6386 if (PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6387 ID local = pm_constant_id_lookup(scope_node, param->name);
6388 local_table_for_iseq->ids[local_index] = local;
6389 }
6390 else {
6391 pm_insert_local_index(param->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6392 }
6393
6394 break;
6395 }
6396 default:
6397 rb_bug("Unsupported node in requireds in parameters %s", pm_node_type_to_str(PM_NODE_TYPE(required)));
6398 }
6399 }
6400
6401 body->param.lead_num = (int) requireds_list->size;
6402 body->param.flags.has_lead = true;
6403 }
6404
6405 if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
6406 local_table_for_iseq->ids[local_index++] = idItImplicit;
6407 }
6408
6409 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6410 // ^^^^^
6411 if (optionals_list && optionals_list->size) {
6412 body->param.opt_num = (int) optionals_list->size;
6413 body->param.flags.has_opt = true;
6414
6415 for (size_t i = 0; i < optionals_list->size; i++, local_index++) {
6416 pm_node_t * node = optionals_list->nodes[i];
6417 pm_constant_id_t name = ((const pm_optional_parameter_node_t *) node)->name;
6418
6419 if (PM_NODE_FLAG_P(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6420 ID local = pm_constant_id_lookup(scope_node, name);
6421 local_table_for_iseq->ids[local_index] = local;
6422 }
6423 else {
6424 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6425 }
6426 }
6427 }
6428
6429 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6430 // ^^
6431 if (parameters_node && parameters_node->rest) {
6432 body->param.rest_start = local_index;
6433
6434 // If there's a trailing comma, we'll have an implicit rest node,
6435 // and we don't want it to impact the rest variables on param
6436 if (!(PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE))) {
6437 body->param.flags.has_rest = true;
6438 RUBY_ASSERT(body->param.rest_start != -1);
6439
6440 pm_constant_id_t name = ((const pm_rest_parameter_node_t *) parameters_node->rest)->name;
6441
6442 if (name) {
6443 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6444 // ^^
6445 if (PM_NODE_FLAG_P(parameters_node->rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6446 ID local = pm_constant_id_lookup(scope_node, name);
6447 local_table_for_iseq->ids[local_index] = local;
6448 }
6449 else {
6450 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6451 }
6452 }
6453 else {
6454 // def foo(a, (b, *c, d), e = 1, *, g, (h, *i, j), k:, l: 1, **m, &n)
6455 // ^
6456 body->param.flags.anon_rest = true;
6457 pm_insert_local_special(idMULT, local_index, index_lookup_table, local_table_for_iseq);
6458 }
6459
6460 local_index++;
6461 }
6462 }
6463
6464 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6465 // ^^^^^^^^^^^^^
6466 if (posts_list && posts_list->size) {
6467 body->param.post_num = (int) posts_list->size;
6468 body->param.post_start = local_index;
6469 body->param.flags.has_post = true;
6470
6471 for (size_t i = 0; i < posts_list->size; i++, local_index++) {
6472 ID local;
6473
6474 // For each MultiTargetNode, we're going to have one additional
6475 // anonymous local not represented in the locals table. We want
6476 // to account for this in our table size.
6477 const pm_node_t *post_node = posts_list->nodes[i];
6478
6479 switch (PM_NODE_TYPE(post_node)) {
6480 case PM_MULTI_TARGET_NODE: {
6481 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6482 // ^^^^^^^^^^
6483 local = rb_make_temporary_id(local_index);
6484 local_table_for_iseq->ids[local_index] = local;
6485 break;
6486 }
6487 case PM_REQUIRED_PARAMETER_NODE: {
6488 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6489 // ^
6490 const pm_required_parameter_node_t *param = (const pm_required_parameter_node_t *) post_node;
6491
6492 if (PM_NODE_FLAG_P(param, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6493 ID local = pm_constant_id_lookup(scope_node, param->name);
6494 local_table_for_iseq->ids[local_index] = local;
6495 }
6496 else {
6497 pm_insert_local_index(param->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6498 }
6499 break;
6500 }
6501 default:
6502 rb_bug("Unsupported node in posts in parameters %s", pm_node_type_to_str(PM_NODE_TYPE(post_node)));
6503 }
6504 }
6505 }
6506
6507 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6508 // ^^^^^^^^
6509 // Keywords create an internal variable on the parse tree
6510 if (keywords_list && keywords_list->size) {
6511 keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6512 keyword->num = (int) keywords_list->size;
6513
6514 const VALUE default_values = rb_ary_hidden_new(1);
6515 const VALUE complex_mark = rb_str_tmp_new(0);
6516
6517 for (size_t i = 0; i < keywords_list->size; i++) {
6518 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6519 pm_constant_id_t name;
6520
6521 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6522 // ^^
6523 if (PM_NODE_TYPE_P(keyword_parameter_node, PM_REQUIRED_KEYWORD_PARAMETER_NODE)) {
6524 name = ((const pm_required_keyword_parameter_node_t *) keyword_parameter_node)->name;
6525 keyword->required_num++;
6526 ID local = pm_constant_id_lookup(scope_node, name);
6527
6528 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6529 local_table_for_iseq->ids[local_index] = local;
6530 }
6531 else {
6532 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6533 }
6534 local_index++;
6535 }
6536 }
6537
6538 for (size_t i = 0; i < keywords_list->size; i++) {
6539 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6540 pm_constant_id_t name;
6541
6542 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6543 // ^^^^
6544 if (PM_NODE_TYPE_P(keyword_parameter_node, PM_OPTIONAL_KEYWORD_PARAMETER_NODE)) {
6545 const pm_optional_keyword_parameter_node_t *cast = ((const pm_optional_keyword_parameter_node_t *) keyword_parameter_node);
6546
6547 pm_node_t *value = cast->value;
6548 name = cast->name;
6549
6550 if (PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) && !PM_CONTAINER_P(value)) {
6551 rb_ary_push(default_values, pm_static_literal_value(iseq, value, scope_node));
6552 }
6553 else {
6554 rb_ary_push(default_values, complex_mark);
6555 }
6556
6557 ID local = pm_constant_id_lookup(scope_node, name);
6558 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6559 local_table_for_iseq->ids[local_index] = local;
6560 }
6561 else {
6562 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6563 }
6564 local_index++;
6565 }
6566
6567 }
6568
6569 if (RARRAY_LEN(default_values)) {
6570 VALUE *dvs = ALLOC_N(VALUE, RARRAY_LEN(default_values));
6571
6572 for (int i = 0; i < RARRAY_LEN(default_values); i++) {
6573 VALUE dv = RARRAY_AREF(default_values, i);
6574 if (dv == complex_mark) dv = Qundef;
6575 RB_OBJ_WRITE(iseq, &dvs[i], dv);
6576 }
6577
6578 keyword->default_values = dvs;
6579 }
6580
6581 // Hidden local for keyword arguments
6582 keyword->bits_start = local_index;
6583 ID local = rb_make_temporary_id(local_index);
6584 local_table_for_iseq->ids[local_index] = local;
6585 local_index++;
6586
6587 body->param.keyword = keyword;
6588 body->param.flags.has_kw = true;
6589 }
6590
6591 if (body->type == ISEQ_TYPE_BLOCK && local_index == 1 && requireds_list && requireds_list->size == 1 && !trailing_comma) {
6592 body->param.flags.ambiguous_param0 = true;
6593 }
6594
6595 if (parameters_node) {
6596 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6597 // ^^^
6598 if (parameters_node->keyword_rest) {
6599 switch (PM_NODE_TYPE(parameters_node->keyword_rest)) {
6600 case PM_NO_KEYWORDS_PARAMETER_NODE: {
6601 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **nil, &n)
6602 // ^^^^^
6603 body->param.flags.accepts_no_kwarg = true;
6604 break;
6605 }
6606 case PM_KEYWORD_REST_PARAMETER_NODE: {
6607 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6608 // ^^^
6609 const pm_keyword_rest_parameter_node_t *kw_rest_node = (const pm_keyword_rest_parameter_node_t *) parameters_node->keyword_rest;
6610 if (!body->param.flags.has_kw) {
6611 body->param.keyword = keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6612 }
6613
6614 keyword->rest_start = local_index;
6615 body->param.flags.has_kwrest = true;
6616
6617 pm_constant_id_t constant_id = kw_rest_node->name;
6618 if (constant_id) {
6619 if (PM_NODE_FLAG_P(kw_rest_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6620 ID local = pm_constant_id_lookup(scope_node, constant_id);
6621 local_table_for_iseq->ids[local_index] = local;
6622 }
6623 else {
6624 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6625 }
6626 }
6627 else {
6628 body->param.flags.anon_kwrest = true;
6629 pm_insert_local_special(idPow, local_index, index_lookup_table, local_table_for_iseq);
6630 }
6631
6632 local_index++;
6633 break;
6634 }
6635 case PM_FORWARDING_PARAMETER_NODE: {
6636 // def foo(...)
6637 // ^^^
6638 if (!ISEQ_BODY(iseq)->param.flags.forwardable) {
6639 // Add the anonymous *
6640 body->param.rest_start = local_index;
6641 body->param.flags.has_rest = true;
6642 body->param.flags.anon_rest = true;
6643 pm_insert_local_special(idMULT, local_index++, index_lookup_table, local_table_for_iseq);
6644
6645 // Add the anonymous **
6646 RUBY_ASSERT(!body->param.flags.has_kw);
6647 body->param.flags.has_kw = false;
6648 body->param.flags.has_kwrest = true;
6649 body->param.flags.anon_kwrest = true;
6650 body->param.keyword = keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6651 keyword->rest_start = local_index;
6652 pm_insert_local_special(idPow, local_index++, index_lookup_table, local_table_for_iseq);
6653
6654 // Add the anonymous &
6655 body->param.block_start = local_index;
6656 body->param.flags.has_block = true;
6657 pm_insert_local_special(idAnd, local_index++, index_lookup_table, local_table_for_iseq);
6658 }
6659
6660 // Add the ...
6661 pm_insert_local_special(idDot3, local_index++, index_lookup_table, local_table_for_iseq);
6662 break;
6663 }
6664 default:
6665 rb_bug("node type %s not expected as keyword_rest", pm_node_type_to_str(PM_NODE_TYPE(parameters_node->keyword_rest)));
6666 }
6667 }
6668
6669 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6670 // ^^
6671 if (parameters_node->block) {
6672 body->param.block_start = local_index;
6673 body->param.flags.has_block = true;
6674 iseq_set_use_block(iseq);
6675
6676 pm_constant_id_t name = ((const pm_block_parameter_node_t *) parameters_node->block)->name;
6677
6678 if (name) {
6679 if (PM_NODE_FLAG_P(parameters_node->block, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6680 ID local = pm_constant_id_lookup(scope_node, name);
6681 local_table_for_iseq->ids[local_index] = local;
6682 }
6683 else {
6684 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6685 }
6686 }
6687 else {
6688 pm_insert_local_special(idAnd, local_index, index_lookup_table, local_table_for_iseq);
6689 }
6690
6691 local_index++;
6692 }
6693 }
6694
6695 //********END OF STEP 2**********
6696 // The local table is now consistent with expected
6697 // stack layout
6698
6699 // If there's only one required element in the parameters
6700 // CRuby needs to recognize it as an ambiguous parameter
6701
6702 //********STEP 3**********
6703 // Goal: fill in the names of the parameters in MultiTargetNodes
6704 //
6705 // Go through requireds again to set the multis
6706
6707 if (requireds_list && requireds_list->size) {
6708 for (size_t i = 0; i < requireds_list->size; i++) {
6709 // For each MultiTargetNode, we're going to have one
6710 // additional anonymous local not represented in the locals table
6711 // We want to account for this in our table size
6712 const pm_node_t *required = requireds_list->nodes[i];
6713
6714 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6715 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);
6716 }
6717 }
6718 }
6719
6720 // Go through posts again to set the multis
6721 if (posts_list && posts_list->size) {
6722 for (size_t i = 0; i < posts_list->size; i++) {
6723 // For each MultiTargetNode, we're going to have one
6724 // additional anonymous local not represented in the locals table
6725 // We want to account for this in our table size
6726 const pm_node_t *post = posts_list->nodes[i];
6727
6728 if (PM_NODE_TYPE_P(post, PM_MULTI_TARGET_NODE)) {
6729 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);
6730 }
6731 }
6732 }
6733
6734 // Set any anonymous locals for the for node
6735 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) {
6736 if (PM_NODE_TYPE_P(((const pm_for_node_t *) scope_node->ast_node)->index, PM_LOCAL_VARIABLE_TARGET_NODE)) {
6737 body->param.lead_num++;
6738 }
6739 else {
6740 body->param.rest_start = local_index;
6741 body->param.flags.has_rest = true;
6742 }
6743
6744 ID local = rb_make_temporary_id(local_index);
6745 local_table_for_iseq->ids[local_index] = local;
6746 local_index++;
6747 }
6748
6749 // Fill in any NumberedParameters, if they exist
6750 if (scope_node->parameters && PM_NODE_TYPE_P(scope_node->parameters, PM_NUMBERED_PARAMETERS_NODE)) {
6751 int maximum = ((const pm_numbered_parameters_node_t *) scope_node->parameters)->maximum;
6752 RUBY_ASSERT(0 < maximum && maximum <= 9);
6753 for (int i = 0; i < maximum; i++, local_index++) {
6754 const uint8_t param_name[] = { '_', '1' + i };
6755 pm_constant_id_t constant_id = pm_constant_pool_find(&scope_node->parser->constant_pool, param_name, 2);
6756 RUBY_ASSERT(constant_id && "parser should fill in any gaps in numbered parameters");
6757 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6758 }
6759 body->param.lead_num = maximum;
6760 body->param.flags.has_lead = true;
6761 }
6762
6763 // Fill in the anonymous `it` parameter, if it exists
6764 if (scope_node->parameters && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
6765 body->param.lead_num = 1;
6766 body->param.flags.has_lead = true;
6767 }
6768
6769 //********END OF STEP 3**********
6770
6771 //********STEP 4**********
6772 // Goal: fill in the method body locals
6773 // To be explicit, these are the non-parameter locals
6774 // We fill in the block_locals, if they exist
6775 // lambda { |x; y| y }
6776 // ^
6777 if (block_locals && block_locals->size) {
6778 for (size_t i = 0; i < block_locals->size; i++, local_index++) {
6779 pm_constant_id_t constant_id = ((const pm_block_local_variable_node_t *) block_locals->nodes[i])->name;
6780 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6781 }
6782 }
6783
6784 // Fill in any locals we missed
6785 if (scope_node->locals.size) {
6786 for (size_t i = 0; i < scope_node->locals.size; i++) {
6787 pm_constant_id_t constant_id = locals->ids[i];
6788 if (constant_id) {
6789 struct pm_local_table_insert_ctx ctx;
6790 ctx.scope_node = scope_node;
6791 ctx.local_table_for_iseq = local_table_for_iseq;
6792 ctx.local_index = local_index;
6793
6794 st_update(index_lookup_table, (st_data_t)constant_id, pm_local_table_insert_func, (st_data_t)&ctx);
6795
6796 local_index = ctx.local_index;
6797 }
6798 }
6799 }
6800
6801 //********END OF STEP 4**********
6802
6803 // We set the index_lookup_table on the scope node so we can
6804 // refer to the parameters correctly
6805 if (scope_node->index_lookup_table) {
6806 st_free_table(scope_node->index_lookup_table);
6807 }
6808 scope_node->index_lookup_table = index_lookup_table;
6809 iseq_calc_param_size(iseq);
6810
6811 if (ISEQ_BODY(iseq)->param.flags.forwardable) {
6812 // We're treating `...` as a parameter so that frame
6813 // pushing won't clobber it.
6814 ISEQ_BODY(iseq)->param.size += 1;
6815 }
6816
6817 // FIXME: args?
6818 iseq_set_local_table(iseq, local_table_for_iseq, 0);
6819 iseq_set_parameters_lvar_state(iseq);
6820
6821 scope_node->local_table_for_iseq_size = local_table_for_iseq->size;
6822
6823 if (keyword != NULL) {
6824 size_t keyword_start_index = keyword->bits_start - keyword->num;
6825 keyword->table = (ID *)&ISEQ_BODY(iseq)->local_table[keyword_start_index];
6826 }
6827
6828 //********STEP 5************
6829 // Goal: compile anything that needed to be compiled
6830 if (optionals_list && optionals_list->size) {
6831 LABEL **opt_table = (LABEL **) ALLOC_N(VALUE, optionals_list->size + 1);
6832 LABEL *label;
6833
6834 // TODO: Should we make an api for NEW_LABEL where you can pass
6835 // a pointer to the label it should fill out? We already
6836 // have a list of labels allocated above so it seems wasteful
6837 // to do the copies.
6838 for (size_t i = 0; i < optionals_list->size; i++) {
6839 label = NEW_LABEL(location.line);
6840 opt_table[i] = label;
6841 PUSH_LABEL(ret, label);
6842 pm_node_t *optional_node = optionals_list->nodes[i];
6843 PM_COMPILE_NOT_POPPED(optional_node);
6844 }
6845
6846 // Set the last label
6847 label = NEW_LABEL(location.line);
6848 opt_table[optionals_list->size] = label;
6849 PUSH_LABEL(ret, label);
6850
6851 body->param.opt_table = (const VALUE *) opt_table;
6852 }
6853
6854 if (keywords_list && keywords_list->size) {
6855 size_t optional_index = 0;
6856 for (size_t i = 0; i < keywords_list->size; i++) {
6857 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6858 pm_constant_id_t name;
6859
6860 switch (PM_NODE_TYPE(keyword_parameter_node)) {
6861 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
6862 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6863 // ^^^^
6864 const pm_optional_keyword_parameter_node_t *cast = ((const pm_optional_keyword_parameter_node_t *) keyword_parameter_node);
6865
6866 pm_node_t *value = cast->value;
6867 name = cast->name;
6868
6869 if (!PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) || PM_CONTAINER_P(value)) {
6870 LABEL *end_label = NEW_LABEL(location.line);
6871
6872 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, name, 0);
6873 int kw_bits_idx = table_size - body->param.keyword->bits_start;
6874 PUSH_INSN2(ret, location, checkkeyword, INT2FIX(kw_bits_idx + VM_ENV_DATA_SIZE - 1), INT2FIX(optional_index));
6875 PUSH_INSNL(ret, location, branchif, end_label);
6876 PM_COMPILE(value);
6877 PUSH_SETLOCAL(ret, location, index.index, index.level);
6878 PUSH_LABEL(ret, end_label);
6879 }
6880 optional_index++;
6881 break;
6882 }
6883 case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
6884 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6885 // ^^
6886 break;
6887 default:
6888 rb_bug("Unexpected keyword parameter node type %s", pm_node_type_to_str(PM_NODE_TYPE(keyword_parameter_node)));
6889 }
6890 }
6891 }
6892
6893 if (requireds_list && requireds_list->size) {
6894 for (size_t i = 0; i < requireds_list->size; i++) {
6895 // For each MultiTargetNode, we're going to have one additional
6896 // anonymous local not represented in the locals table. We want
6897 // to account for this in our table size.
6898 const pm_node_t *required = requireds_list->nodes[i];
6899
6900 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6901 PUSH_GETLOCAL(ret, location, table_size - (int)i, 0);
6902 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) required, ret, scope_node);
6903 }
6904 }
6905 }
6906
6907 if (posts_list && posts_list->size) {
6908 for (size_t i = 0; i < posts_list->size; i++) {
6909 // For each MultiTargetNode, we're going to have one additional
6910 // anonymous local not represented in the locals table. We want
6911 // to account for this in our table size.
6912 const pm_node_t *post = posts_list->nodes[i];
6913
6914 if (PM_NODE_TYPE_P(post, PM_MULTI_TARGET_NODE)) {
6915 PUSH_GETLOCAL(ret, location, table_size - body->param.post_start - (int) i, 0);
6916 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) post, ret, scope_node);
6917 }
6918 }
6919 }
6920
6921 switch (body->type) {
6922 case ISEQ_TYPE_PLAIN: {
6923 RUBY_ASSERT(PM_NODE_TYPE_P(scope_node->ast_node, PM_INTERPOLATED_REGULAR_EXPRESSION_NODE));
6924
6925 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) scope_node->ast_node;
6926 pm_compile_regexp_dynamic(iseq, (const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6927
6928 break;
6929 }
6930 case ISEQ_TYPE_BLOCK: {
6931 LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
6932 LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
6933 const pm_node_location_t block_location = { .line = body->location.first_lineno, .node_id = scope_node->ast_node->node_id };
6934
6935 start->rescued = LABEL_RESCUE_BEG;
6936 end->rescued = LABEL_RESCUE_END;
6937
6938 // For nodes automatically assign the iteration variable to whatever
6939 // index variable. We need to handle that write here because it has
6940 // to happen in the context of the block. Note that this happens
6941 // before the B_CALL tracepoint event.
6942 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) {
6943 pm_compile_for_node_index(iseq, ((const pm_for_node_t *) scope_node->ast_node)->index, ret, scope_node);
6944 }
6945
6946 PUSH_TRACE(ret, RUBY_EVENT_B_CALL);
6947 PUSH_INSN(ret, block_location, nop);
6948 PUSH_LABEL(ret, start);
6949
6950 if (scope_node->body != NULL) {
6951 switch (PM_NODE_TYPE(scope_node->ast_node)) {
6952 case PM_POST_EXECUTION_NODE: {
6953 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) scope_node->ast_node;
6954 PUSH_INSN1(ret, block_location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6955
6956 // We create another ScopeNode from the statements within the PostExecutionNode
6957 pm_scope_node_t next_scope_node;
6958 pm_scope_node_init((const pm_node_t *) cast->statements, &next_scope_node, scope_node);
6959
6960 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(body->parent_iseq), ISEQ_TYPE_BLOCK, location.line);
6961 pm_scope_node_destroy(&next_scope_node);
6962
6963 PUSH_CALL_WITH_BLOCK(ret, block_location, id_core_set_postexe, INT2FIX(0), block);
6964 break;
6965 }
6966 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
6967 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) scope_node->ast_node;
6968 pm_compile_regexp_dynamic(iseq, (const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6969 break;
6970 }
6971 default:
6972 pm_compile_node(iseq, scope_node->body, ret, popped, scope_node);
6973 break;
6974 }
6975 }
6976 else {
6977 PUSH_INSN(ret, block_location, putnil);
6978 }
6979
6980 PUSH_LABEL(ret, end);
6981 PUSH_TRACE(ret, RUBY_EVENT_B_RETURN);
6982 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6983
6984 /* wide range catch handler must put at last */
6985 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start);
6986 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end);
6987 break;
6988 }
6989 case ISEQ_TYPE_ENSURE: {
6990 const pm_node_location_t statements_location = (scope_node->body != NULL ? PM_NODE_START_LOCATION(scope_node->parser, scope_node->body) : location);
6991 iseq_set_exception_local_table(iseq);
6992
6993 if (scope_node->body != NULL) {
6994 PM_COMPILE_POPPED((const pm_node_t *) scope_node->body);
6995 }
6996
6997 PUSH_GETLOCAL(ret, statements_location, 1, 0);
6998 PUSH_INSN1(ret, statements_location, throw, INT2FIX(0));
6999 return;
7000 }
7001 case ISEQ_TYPE_METHOD: {
7002 ISEQ_COMPILE_DATA(iseq)->root_node = (const void *) scope_node->body;
7003 PUSH_TRACE(ret, RUBY_EVENT_CALL);
7004
7005 if (scope_node->body) {
7006 PM_COMPILE((const pm_node_t *) scope_node->body);
7007 }
7008 else {
7009 PUSH_INSN(ret, location, putnil);
7010 }
7011
7012 ISEQ_COMPILE_DATA(iseq)->root_node = (const void *) scope_node->body;
7013 PUSH_TRACE(ret, RUBY_EVENT_RETURN);
7014
7015 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
7016 break;
7017 }
7018 case ISEQ_TYPE_RESCUE: {
7019 iseq_set_exception_local_table(iseq);
7020 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_RESCUE_MODIFIER_NODE)) {
7021 LABEL *lab = NEW_LABEL(location.line);
7022 LABEL *rescue_end = NEW_LABEL(location.line);
7023 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
7024 PUSH_INSN1(ret, location, putobject, rb_eStandardError);
7025 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
7026 PUSH_INSNL(ret, location, branchif, lab);
7027 PUSH_INSNL(ret, location, jump, rescue_end);
7028 PUSH_LABEL(ret, lab);
7029 PUSH_TRACE(ret, RUBY_EVENT_RESCUE);
7030 PM_COMPILE((const pm_node_t *) scope_node->body);
7031 PUSH_INSN(ret, location, leave);
7032 PUSH_LABEL(ret, rescue_end);
7033 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
7034 }
7035 else {
7036 PM_COMPILE((const pm_node_t *) scope_node->ast_node);
7037 }
7038 PUSH_INSN1(ret, location, throw, INT2FIX(0));
7039
7040 return;
7041 }
7042 default:
7043 if (scope_node->body) {
7044 PM_COMPILE((const pm_node_t *) scope_node->body);
7045 }
7046 else {
7047 PUSH_INSN(ret, location, putnil);
7048 }
7049 break;
7050 }
7051
7052 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE) || PM_NODE_TYPE_P(scope_node->ast_node, PM_MODULE_NODE)) {
7053 const pm_node_location_t end_location = PM_NODE_END_LOCATION(scope_node->parser, scope_node->ast_node);
7054 PUSH_TRACE(ret, RUBY_EVENT_END);
7055 ISEQ_COMPILE_DATA(iseq)->last_line = end_location.line;
7056 }
7057
7058 if (!PM_NODE_TYPE_P(scope_node->ast_node, PM_ENSURE_NODE)) {
7059 const pm_node_location_t location = { .line = ISEQ_COMPILE_DATA(iseq)->last_line, .node_id = scope_node->ast_node->node_id };
7060 PUSH_INSN(ret, location, leave);
7061 }
7062}
7063
7064static inline void
7065pm_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)
7066{
7067 // alias $foo $bar
7068 // ^^^^^^^^^^^^^^^
7069 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7070
7071 {
7072 const pm_location_t *name_loc = &node->new_name->location;
7073 VALUE operand = ID2SYM(rb_intern3((const char *) name_loc->start, name_loc->end - name_loc->start, scope_node->encoding));
7074 PUSH_INSN1(ret, *location, putobject, operand);
7075 }
7076
7077 {
7078 const pm_location_t *name_loc = &node->old_name->location;
7079 VALUE operand = ID2SYM(rb_intern3((const char *) name_loc->start, name_loc->end - name_loc->start, scope_node->encoding));
7080 PUSH_INSN1(ret, *location, putobject, operand);
7081 }
7082
7083 PUSH_SEND(ret, *location, id_core_set_variable_alias, INT2FIX(2));
7084 if (popped) PUSH_INSN(ret, *location, pop);
7085}
7086
7087static inline void
7088pm_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)
7089{
7090 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7091 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
7092 PM_COMPILE_NOT_POPPED(node->new_name);
7093 PM_COMPILE_NOT_POPPED(node->old_name);
7094
7095 PUSH_SEND(ret, *location, id_core_set_method_alias, INT2FIX(3));
7096 if (popped) PUSH_INSN(ret, *location, pop);
7097}
7098
7099static inline void
7100pm_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)
7101{
7102 LABEL *end_label = NEW_LABEL(location->line);
7103
7104 PM_COMPILE_NOT_POPPED(node->left);
7105 if (!popped) PUSH_INSN(ret, *location, dup);
7106 PUSH_INSNL(ret, *location, branchunless, end_label);
7107
7108 if (!popped) PUSH_INSN(ret, *location, pop);
7109 PM_COMPILE(node->right);
7110 PUSH_LABEL(ret, end_label);
7111}
7112
7113static inline void
7114pm_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)
7115{
7116 // If every node in the array is static, then we can compile the entire
7117 // array now instead of later.
7118 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
7119 // We're only going to compile this node if it's not popped. If it
7120 // is popped, then we know we don't need to do anything since it's
7121 // statically known.
7122 if (!popped) {
7123 if (elements->size) {
7124 VALUE value = pm_static_literal_value(iseq, node, scope_node);
7125 RB_OBJ_SET_FROZEN_SHAREABLE(value);
7126 PUSH_INSN1(ret, *location, duparray, value);
7127 }
7128 else {
7129 PUSH_INSN1(ret, *location, newarray, INT2FIX(0));
7130 }
7131 }
7132 return;
7133 }
7134
7135 // Here since we know there are possible side-effects inside the
7136 // array contents, we're going to build it entirely at runtime.
7137 // We'll do this by pushing all of the elements onto the stack and
7138 // then combining them with newarray.
7139 //
7140 // If this array is popped, then this serves only to ensure we enact
7141 // all side-effects (like method calls) that are contained within
7142 // the array contents.
7143 //
7144 // We treat all sequences of non-splat elements as their
7145 // own arrays, followed by a newarray, and then continually
7146 // concat the arrays with the SplatNode nodes.
7147 const int max_new_array_size = 0x100;
7148 const unsigned int min_tmp_array_size = 0x40;
7149
7150 int new_array_size = 0;
7151 bool first_chunk = true;
7152
7153 // This is an optimization wherein we keep track of whether or not
7154 // the previous element was a static literal. If it was, then we do
7155 // not attempt to check if we have a subarray that can be optimized.
7156 // If it was not, then we do check.
7157 bool static_literal = false;
7158
7159 // Either create a new array, or push to the existing array.
7160#define FLUSH_CHUNK \
7161 if (new_array_size) { \
7162 if (first_chunk) PUSH_INSN1(ret, *location, newarray, INT2FIX(new_array_size)); \
7163 else PUSH_INSN1(ret, *location, pushtoarray, INT2FIX(new_array_size)); \
7164 first_chunk = false; \
7165 new_array_size = 0; \
7166 }
7167
7168 for (size_t index = 0; index < elements->size; index++) {
7169 const pm_node_t *element = elements->nodes[index];
7170
7171 if (PM_NODE_TYPE_P(element, PM_SPLAT_NODE)) {
7172 FLUSH_CHUNK;
7173
7174 const pm_splat_node_t *splat_element = (const pm_splat_node_t *) element;
7175 if (splat_element->expression) {
7176 PM_COMPILE_NOT_POPPED(splat_element->expression);
7177 }
7178 else {
7179 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
7180 PUSH_GETLOCAL(ret, *location, index.index, index.level);
7181 }
7182
7183 if (first_chunk) {
7184 // If this is the first element of the array then we
7185 // need to splatarray the elements into the list.
7186 PUSH_INSN1(ret, *location, splatarray, Qtrue);
7187 first_chunk = false;
7188 }
7189 else {
7190 PUSH_INSN(ret, *location, concattoarray);
7191 }
7192
7193 static_literal = false;
7194 }
7195 else if (PM_NODE_TYPE_P(element, PM_KEYWORD_HASH_NODE)) {
7196 if (new_array_size == 0 && first_chunk) {
7197 PUSH_INSN1(ret, *location, newarray, INT2FIX(0));
7198 first_chunk = false;
7199 }
7200 else {
7201 FLUSH_CHUNK;
7202 }
7203
7204 // If we get here, then this is the last element of the
7205 // array/arguments, because it cannot be followed by
7206 // anything else without a syntax error. This looks like:
7207 //
7208 // [foo, bar, baz: qux]
7209 // ^^^^^^^^
7210 //
7211 // [foo, bar, **baz]
7212 // ^^^^^
7213 //
7214 const pm_keyword_hash_node_t *keyword_hash = (const pm_keyword_hash_node_t *) element;
7215 pm_compile_hash_elements(iseq, element, &keyword_hash->elements, 0, Qundef, false, ret, scope_node);
7216
7217 // This boolean controls the manner in which we push the
7218 // hash onto the array. If it's all keyword splats, then we
7219 // can use the very specialized pushtoarraykwsplat
7220 // instruction to check if it's empty before we push it.
7221 size_t splats = 0;
7222 while (splats < keyword_hash->elements.size && PM_NODE_TYPE_P(keyword_hash->elements.nodes[splats], PM_ASSOC_SPLAT_NODE)) splats++;
7223
7224 if (keyword_hash->elements.size == splats) {
7225 PUSH_INSN(ret, *location, pushtoarraykwsplat);
7226 }
7227 else {
7228 new_array_size++;
7229 }
7230 }
7231 else if (
7232 PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL) &&
7233 !PM_CONTAINER_P(element) &&
7234 !static_literal &&
7235 ((index + min_tmp_array_size) < elements->size)
7236 ) {
7237 // If we have a static literal, then there's the potential
7238 // to group a bunch of them together with a literal array
7239 // and then concat them together.
7240 size_t right_index = index + 1;
7241 while (
7242 right_index < elements->size &&
7243 PM_NODE_FLAG_P(elements->nodes[right_index], PM_NODE_FLAG_STATIC_LITERAL) &&
7244 !PM_CONTAINER_P(elements->nodes[right_index])
7245 ) right_index++;
7246
7247 size_t tmp_array_size = right_index - index;
7248 if (tmp_array_size >= min_tmp_array_size) {
7249 VALUE tmp_array = rb_ary_hidden_new(tmp_array_size);
7250
7251 // Create the temporary array.
7252 for (; tmp_array_size; tmp_array_size--)
7253 rb_ary_push(tmp_array, pm_static_literal_value(iseq, elements->nodes[index++], scope_node));
7254
7255 index--; // about to be incremented by for loop
7256 RB_OBJ_SET_FROZEN_SHAREABLE(tmp_array);
7257
7258 // Emit the optimized code.
7259 FLUSH_CHUNK;
7260 if (first_chunk) {
7261 PUSH_INSN1(ret, *location, duparray, tmp_array);
7262 first_chunk = false;
7263 }
7264 else {
7265 PUSH_INSN1(ret, *location, putobject, tmp_array);
7266 PUSH_INSN(ret, *location, concattoarray);
7267 }
7268 }
7269 else {
7270 PM_COMPILE_NOT_POPPED(element);
7271 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7272 static_literal = true;
7273 }
7274 } else {
7275 PM_COMPILE_NOT_POPPED(element);
7276 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7277 static_literal = false;
7278 }
7279 }
7280
7281 FLUSH_CHUNK;
7282 if (popped) PUSH_INSN(ret, *location, pop);
7283
7284#undef FLUSH_CHUNK
7285}
7286
7287static inline void
7288pm_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)
7289{
7290 unsigned long throw_flag = 0;
7291
7292 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
7293 /* while/until */
7294 LABEL *splabel = NEW_LABEL(0);
7295 PUSH_LABEL(ret, splabel);
7296 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
7297
7298 if (node->arguments != NULL) {
7299 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
7300 }
7301 else {
7302 PUSH_INSN(ret, *location, putnil);
7303 }
7304
7305 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7306 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
7307 PUSH_ADJUST_RESTORE(ret, splabel);
7308 if (!popped) PUSH_INSN(ret, *location, putnil);
7309 }
7310 else {
7311 const rb_iseq_t *ip = iseq;
7312
7313 while (ip) {
7314 if (!ISEQ_COMPILE_DATA(ip)) {
7315 ip = 0;
7316 break;
7317 }
7318
7319 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
7320 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
7321 }
7322 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
7323 throw_flag = 0;
7324 }
7325 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
7326 COMPILE_ERROR(iseq, location->line, "Invalid break");
7327 return;
7328 }
7329 else {
7330 ip = ISEQ_BODY(ip)->parent_iseq;
7331 continue;
7332 }
7333
7334 /* escape from block */
7335 if (node->arguments != NULL) {
7336 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
7337 }
7338 else {
7339 PUSH_INSN(ret, *location, putnil);
7340 }
7341
7342 PUSH_INSN1(ret, *location, throw, INT2FIX(throw_flag | TAG_BREAK));
7343 if (popped) PUSH_INSN(ret, *location, pop);
7344
7345 return;
7346 }
7347
7348 COMPILE_ERROR(iseq, location->line, "Invalid break");
7349 }
7350}
7351
7352static inline void
7353pm_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)
7354{
7355 ID method_id = pm_constant_id_lookup(scope_node, node->name);
7356
7357 const pm_location_t *message_loc = &node->message_loc;
7358 if (message_loc->start == NULL) message_loc = &node->base.location;
7359
7360 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, message_loc, node->base.node_id);
7361 const char *builtin_func;
7362
7363 if (UNLIKELY(iseq_has_builtin_function_table(iseq)) && (builtin_func = pm_iseq_builtin_function_name(scope_node, node->receiver, method_id)) != NULL) {
7364 pm_compile_builtin_function_call(iseq, ret, scope_node, node, &location, popped, ISEQ_COMPILE_DATA(iseq)->current_block, builtin_func);
7365 return;
7366 }
7367
7368 LABEL *start = NEW_LABEL(location.line);
7369 if (node->block) PUSH_LABEL(ret, start);
7370
7371 switch (method_id) {
7372 case idUMinus: {
7373 if (pm_opt_str_freeze_p(iseq, node)) {
7374 VALUE value = parse_static_literal_string(iseq, scope_node, node->receiver, &((const pm_string_node_t * ) node->receiver)->unescaped);
7375 const struct rb_callinfo *callinfo = new_callinfo(iseq, idUMinus, 0, 0, NULL, FALSE);
7376 PUSH_INSN2(ret, location, opt_str_uminus, value, callinfo);
7377 if (popped) PUSH_INSN(ret, location, pop);
7378 return;
7379 }
7380 break;
7381 }
7382 case idFreeze: {
7383 if (pm_opt_str_freeze_p(iseq, node)) {
7384 VALUE value = parse_static_literal_string(iseq, scope_node, node->receiver, &((const pm_string_node_t * ) node->receiver)->unescaped);
7385 const struct rb_callinfo *callinfo = new_callinfo(iseq, idFreeze, 0, 0, NULL, FALSE);
7386 PUSH_INSN2(ret, location, opt_str_freeze, value, callinfo);
7387 if (popped) PUSH_INSN(ret, location, pop);
7388 return;
7389 }
7390 break;
7391 }
7392 }
7393
7394 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) && !popped) {
7395 PUSH_INSN(ret, location, putnil);
7396 }
7397
7398 if (node->receiver == NULL) {
7399 PUSH_INSN(ret, location, putself);
7400 }
7401 else {
7402 if (method_id == idCall && PM_NODE_TYPE_P(node->receiver, PM_LOCAL_VARIABLE_READ_NODE)) {
7403 const pm_local_variable_read_node_t *read_node_cast = (const pm_local_variable_read_node_t *) node->receiver;
7404 uint32_t node_id = node->receiver->node_id;
7405 int idx, level;
7406
7407 if (iseq_block_param_id_p(iseq, pm_constant_id_lookup(scope_node, read_node_cast->name), &idx, &level)) {
7408 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)));
7409 }
7410 else {
7411 PM_COMPILE_NOT_POPPED(node->receiver);
7412 }
7413 }
7414 else {
7415 PM_COMPILE_NOT_POPPED(node->receiver);
7416 }
7417 }
7418
7419 pm_compile_call(iseq, node, ret, popped, scope_node, method_id, start);
7420 return;
7421}
7422
7423static inline void
7424pm_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)
7425{
7426 int flag = 0;
7427
7428 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
7429 flag = VM_CALL_FCALL;
7430 }
7431
7432 PM_COMPILE_NOT_POPPED(node->receiver);
7433
7434 LABEL *safe_label = NULL;
7435 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
7436 safe_label = NEW_LABEL(location->line);
7437 PUSH_INSN(ret, *location, dup);
7438 PUSH_INSNL(ret, *location, branchnil, safe_label);
7439 }
7440
7441 PUSH_INSN(ret, *location, dup);
7442
7443 ID id_read_name = pm_constant_id_lookup(scope_node, node->read_name);
7444 PUSH_SEND_WITH_FLAG(ret, *location, id_read_name, INT2FIX(0), INT2FIX(flag));
7445
7446 PM_COMPILE_NOT_POPPED(node->value);
7447 ID id_operator = pm_constant_id_lookup(scope_node, node->binary_operator);
7448 PUSH_SEND(ret, *location, id_operator, INT2FIX(1));
7449
7450 if (!popped) {
7451 PUSH_INSN(ret, *location, swap);
7452 PUSH_INSN1(ret, *location, topn, INT2FIX(1));
7453 }
7454
7455 ID id_write_name = pm_constant_id_lookup(scope_node, node->write_name);
7456 PUSH_SEND_WITH_FLAG(ret, *location, id_write_name, INT2FIX(1), INT2FIX(flag));
7457
7458 if (safe_label != NULL && popped) PUSH_LABEL(ret, safe_label);
7459 PUSH_INSN(ret, *location, pop);
7460 if (safe_label != NULL && !popped) PUSH_LABEL(ret, safe_label);
7461}
7462
7479static VALUE
7480pm_compile_case_node_dispatch(rb_iseq_t *iseq, VALUE dispatch, const pm_node_t *node, LABEL *label, const pm_scope_node_t *scope_node)
7481{
7482 VALUE key = Qundef;
7483 switch (PM_NODE_TYPE(node)) {
7484 case PM_FLOAT_NODE: {
7485 key = pm_static_literal_value(iseq, node, scope_node);
7486 double intptr;
7487
7488 if (modf(RFLOAT_VALUE(key), &intptr) == 0.0) {
7489 key = (FIXABLE(intptr) ? LONG2FIX((long) intptr) : rb_dbl2big(intptr));
7490 }
7491
7492 break;
7493 }
7494 case PM_FALSE_NODE:
7495 case PM_INTEGER_NODE:
7496 case PM_NIL_NODE:
7497 case PM_SOURCE_FILE_NODE:
7498 case PM_SOURCE_LINE_NODE:
7499 case PM_SYMBOL_NODE:
7500 case PM_TRUE_NODE:
7501 key = pm_static_literal_value(iseq, node, scope_node);
7502 break;
7503 case PM_STRING_NODE: {
7504 const pm_string_node_t *cast = (const pm_string_node_t *) node;
7505 key = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
7506 break;
7507 }
7508 default:
7509 return Qundef;
7510 }
7511
7512 if (NIL_P(rb_hash_lookup(dispatch, key))) {
7513 rb_hash_aset(dispatch, key, ((VALUE) label) | 1);
7514 }
7515 return dispatch;
7516}
7517
7521static inline void
7522pm_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)
7523{
7524 const pm_parser_t *parser = scope_node->parser;
7525 const pm_node_location_t location = *node_location;
7526 const pm_node_list_t *conditions = &cast->conditions;
7527
7528 // This is the anchor that we will compile the conditions of the various
7529 // `when` nodes into. If a match is found, they will need to jump into
7530 // the body_seq anchor to the correct spot.
7531 DECL_ANCHOR(cond_seq);
7532
7533 // This is the anchor that we will compile the bodies of the various
7534 // `when` nodes into. We'll make sure that the clauses that are compiled
7535 // jump into the correct spots within this anchor.
7536 DECL_ANCHOR(body_seq);
7537
7538 // This is the label where all of the when clauses will jump to if they
7539 // have matched and are done executing their bodies.
7540 LABEL *end_label = NEW_LABEL(location.line);
7541
7542 // If we have a predicate on this case statement, then it's going to
7543 // compare all of the various when clauses to the predicate. If we
7544 // don't, then it's basically an if-elsif-else chain.
7545 if (cast->predicate == NULL) {
7546 // Establish branch coverage for the case node.
7547 VALUE branches = Qfalse;
7548 rb_code_location_t case_location = { 0 };
7549 int branch_id = 0;
7550
7551 if (PM_BRANCH_COVERAGE_P(iseq)) {
7552 case_location = pm_code_location(scope_node, (const pm_node_t *) cast);
7553 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location, "case");
7554 }
7555
7556 // Loop through each clauses in the case node and compile each of
7557 // the conditions within them into cond_seq. If they match, they
7558 // should jump into their respective bodies in body_seq.
7559 for (size_t clause_index = 0; clause_index < conditions->size; clause_index++) {
7560 const pm_when_node_t *clause = (const pm_when_node_t *) conditions->nodes[clause_index];
7561 const pm_node_list_t *conditions = &clause->conditions;
7562
7563 int clause_lineno = pm_node_line_number(parser, (const pm_node_t *) clause);
7564 LABEL *label = NEW_LABEL(clause_lineno);
7565 PUSH_LABEL(body_seq, label);
7566
7567 // Establish branch coverage for the when clause.
7568 if (PM_BRANCH_COVERAGE_P(iseq)) {
7569 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));
7570 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "when", branches);
7571 }
7572
7573 if (clause->statements != NULL) {
7574 pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7575 }
7576 else if (!popped) {
7577 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7578 }
7579
7580 PUSH_INSNL(body_seq, location, jump, end_label);
7581
7582 // Compile each of the conditions for the when clause into the
7583 // cond_seq. Each one should have a unique condition and should
7584 // jump to the subsequent one if it doesn't match.
7585 for (size_t condition_index = 0; condition_index < conditions->size; condition_index++) {
7586 const pm_node_t *condition = conditions->nodes[condition_index];
7587
7588 if (PM_NODE_TYPE_P(condition, PM_SPLAT_NODE)) {
7589 pm_node_location_t cond_location = PM_NODE_START_LOCATION(parser, condition);
7590 PUSH_INSN(cond_seq, cond_location, putnil);
7591 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7592 PUSH_INSN1(cond_seq, cond_location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_WHEN | VM_CHECKMATCH_ARRAY));
7593 PUSH_INSNL(cond_seq, cond_location, branchif, label);
7594 }
7595 else {
7596 LABEL *next_label = NEW_LABEL(pm_node_line_number(parser, condition));
7597 pm_compile_branch_condition(iseq, cond_seq, condition, label, next_label, scope_node);
7598 PUSH_LABEL(cond_seq, next_label);
7599 }
7600 }
7601 }
7602
7603 // Establish branch coverage for the else clause (implicit or
7604 // explicit).
7605 if (PM_BRANCH_COVERAGE_P(iseq)) {
7606 rb_code_location_t branch_location;
7607
7608 if (cast->else_clause == NULL) {
7609 branch_location = case_location;
7610 } else if (cast->else_clause->statements == NULL) {
7611 branch_location = pm_code_location(scope_node, (const pm_node_t *) cast->else_clause);
7612 } else {
7613 branch_location = pm_code_location(scope_node, (const pm_node_t *) cast->else_clause->statements);
7614 }
7615
7616 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7617 }
7618
7619 // Compile the else clause if there is one.
7620 if (cast->else_clause != NULL) {
7621 pm_compile_node(iseq, (const pm_node_t *) cast->else_clause, cond_seq, popped, scope_node);
7622 }
7623 else if (!popped) {
7624 PUSH_SYNTHETIC_PUTNIL(cond_seq, iseq);
7625 }
7626
7627 // Finally, jump to the end label if none of the other conditions
7628 // have matched.
7629 PUSH_INSNL(cond_seq, location, jump, end_label);
7630 PUSH_SEQ(ret, cond_seq);
7631 }
7632 else {
7633 // Establish branch coverage for the case node.
7634 VALUE branches = Qfalse;
7635 rb_code_location_t case_location = { 0 };
7636 int branch_id = 0;
7637
7638 if (PM_BRANCH_COVERAGE_P(iseq)) {
7639 case_location = pm_code_location(scope_node, (const pm_node_t *) cast);
7640 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location, "case");
7641 }
7642
7643 // This is the label where everything will fall into if none of the
7644 // conditions matched.
7645 LABEL *else_label = NEW_LABEL(location.line);
7646
7647 // It's possible for us to speed up the case node by using a
7648 // dispatch hash. This is a hash that maps the conditions of the
7649 // various when clauses to the labels of their bodies. If we can
7650 // compile the conditions into a hash key, then we can use a hash
7651 // lookup to jump directly to the correct when clause body.
7652 VALUE dispatch = Qundef;
7653 if (ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction) {
7654 dispatch = rb_hash_new();
7655 RHASH_TBL_RAW(dispatch)->type = &cdhash_type;
7656 }
7657
7658 // We're going to loop through each of the conditions in the case
7659 // node and compile each of their contents into both the cond_seq
7660 // and the body_seq. Each condition will use its own label to jump
7661 // from its conditions into its body.
7662 //
7663 // Note that none of the code in the loop below should be adding
7664 // anything to ret, as we're going to be laying out the entire case
7665 // node instructions later.
7666 for (size_t clause_index = 0; clause_index < conditions->size; clause_index++) {
7667 const pm_when_node_t *clause = (const pm_when_node_t *) conditions->nodes[clause_index];
7668 pm_node_location_t clause_location = PM_NODE_START_LOCATION(parser, (const pm_node_t *) clause);
7669
7670 const pm_node_list_t *conditions = &clause->conditions;
7671 LABEL *label = NEW_LABEL(clause_location.line);
7672
7673 // Compile each of the conditions for the when clause into the
7674 // cond_seq. Each one should have a unique comparison that then
7675 // jumps into the body if it matches.
7676 for (size_t condition_index = 0; condition_index < conditions->size; condition_index++) {
7677 const pm_node_t *condition = conditions->nodes[condition_index];
7678 const pm_node_location_t condition_location = PM_NODE_START_LOCATION(parser, condition);
7679
7680 // If we haven't already abandoned the optimization, then
7681 // we're going to try to compile the condition into the
7682 // dispatch hash.
7683 if (dispatch != Qundef) {
7684 dispatch = pm_compile_case_node_dispatch(iseq, dispatch, condition, label, scope_node);
7685 }
7686
7687 if (PM_NODE_TYPE_P(condition, PM_SPLAT_NODE)) {
7688 PUSH_INSN(cond_seq, condition_location, dup);
7689 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7690 PUSH_INSN1(cond_seq, condition_location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE | VM_CHECKMATCH_ARRAY));
7691 }
7692 else {
7693 if (PM_NODE_TYPE_P(condition, PM_STRING_NODE)) {
7694 const pm_string_node_t *string = (const pm_string_node_t *) condition;
7695 VALUE value = parse_static_literal_string(iseq, scope_node, condition, &string->unescaped);
7696 PUSH_INSN1(cond_seq, condition_location, putobject, value);
7697 }
7698 else {
7699 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7700 }
7701
7702 PUSH_INSN1(cond_seq, condition_location, topn, INT2FIX(1));
7703 PUSH_SEND_WITH_FLAG(cond_seq, condition_location, idEqq, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
7704 }
7705
7706 PUSH_INSNL(cond_seq, condition_location, branchif, label);
7707 }
7708
7709 // Now, add the label to the body and compile the body of the
7710 // when clause. This involves popping the predicate, compiling
7711 // the statements to be executed, and then compiling a jump to
7712 // the end of the case node.
7713 PUSH_LABEL(body_seq, label);
7714 PUSH_INSN(body_seq, clause_location, pop);
7715
7716 // Establish branch coverage for the when clause.
7717 if (PM_BRANCH_COVERAGE_P(iseq)) {
7718 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));
7719 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "when", branches);
7720 }
7721
7722 if (clause->statements != NULL) {
7723 pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7724 }
7725 else if (!popped) {
7726 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7727 }
7728
7729 PUSH_INSNL(body_seq, clause_location, jump, end_label);
7730 }
7731
7732 // Now that we have compiled the conditions and the bodies of the
7733 // various when clauses, we can compile the predicate, lay out the
7734 // conditions, compile the fallback subsequent if there is one, and
7735 // finally put in the bodies of the when clauses.
7736 PM_COMPILE_NOT_POPPED(cast->predicate);
7737
7738 // If we have a dispatch hash, then we'll use it here to create the
7739 // optimization.
7740 if (dispatch != Qundef) {
7741 PUSH_INSN(ret, location, dup);
7742 RB_OBJ_SET_SHAREABLE(dispatch); // it is special that the hash is shareable but not frozen, because compile.c modify them. This Hahs instance is not accessible so it is safe to leave it.
7743 PUSH_INSN2(ret, location, opt_case_dispatch, dispatch, else_label);
7744 LABEL_REF(else_label);
7745 }
7746
7747 PUSH_SEQ(ret, cond_seq);
7748
7749 // Compile either the explicit else clause or an implicit else
7750 // clause.
7751 PUSH_LABEL(ret, else_label);
7752
7753 if (cast->else_clause != NULL) {
7754 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));
7755 PUSH_INSN(ret, else_location, pop);
7756
7757 // Establish branch coverage for the else clause.
7758 if (PM_BRANCH_COVERAGE_P(iseq)) {
7759 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));
7760 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7761 }
7762
7763 PM_COMPILE((const pm_node_t *) cast->else_clause);
7764 PUSH_INSNL(ret, else_location, jump, end_label);
7765 }
7766 else {
7767 PUSH_INSN(ret, location, pop);
7768
7769 // Establish branch coverage for the implicit else clause.
7770 if (PM_BRANCH_COVERAGE_P(iseq)) {
7771 add_trace_branch_coverage(iseq, ret, &case_location, case_location.beg_pos.column, branch_id, "else", branches);
7772 }
7773
7774 if (!popped) PUSH_INSN(ret, location, putnil);
7775 PUSH_INSNL(ret, location, jump, end_label);
7776 }
7777 }
7778
7779 PUSH_SEQ(ret, body_seq);
7780 PUSH_LABEL(ret, end_label);
7781}
7782
7783static inline void
7784pm_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)
7785{
7786 // This is the anchor that we will compile the bodies of the various
7787 // `in` nodes into. We'll make sure that the patterns that are compiled
7788 // jump into the correct spots within this anchor.
7789 DECL_ANCHOR(body_seq);
7790
7791 // This is the anchor that we will compile the patterns of the various
7792 // `in` nodes into. If a match is found, they will need to jump into the
7793 // body_seq anchor to the correct spot.
7794 DECL_ANCHOR(cond_seq);
7795
7796 // This label is used to indicate the end of the entire node. It is
7797 // jumped to after the entire stack is cleaned up.
7798 LABEL *end_label = NEW_LABEL(location->line);
7799
7800 // This label is used as the fallback for the case match. If no match is
7801 // found, then we jump to this label. This is either an `else` clause or
7802 // an error handler.
7803 LABEL *else_label = NEW_LABEL(location->line);
7804
7805 // We're going to use this to uniquely identify each branch so that we
7806 // can track coverage information.
7807 rb_code_location_t case_location = { 0 };
7808 VALUE branches = Qfalse;
7809 int branch_id = 0;
7810
7811 if (PM_BRANCH_COVERAGE_P(iseq)) {
7812 case_location = pm_code_location(scope_node, (const pm_node_t *) node);
7813 branches = decl_branch_base(iseq, PTR2NUM(node), &case_location, "case");
7814 }
7815
7816 // If there is only one pattern, then the behavior changes a bit. It
7817 // effectively gets treated as a match required node (this is how it is
7818 // represented in the other parser).
7819 bool in_single_pattern = node->else_clause == NULL && node->conditions.size == 1;
7820
7821 // First, we're going to push a bunch of stuff onto the stack that is
7822 // going to serve as our scratch space.
7823 if (in_single_pattern) {
7824 PUSH_INSN(ret, *location, putnil); // key error key
7825 PUSH_INSN(ret, *location, putnil); // key error matchee
7826 PUSH_INSN1(ret, *location, putobject, Qfalse); // key error?
7827 PUSH_INSN(ret, *location, putnil); // error string
7828 }
7829
7830 // Now we're going to compile the value to match against.
7831 PUSH_INSN(ret, *location, putnil); // deconstruct cache
7832 PM_COMPILE_NOT_POPPED(node->predicate);
7833
7834 // Next, we'll loop through every in clause and compile its body into
7835 // the body_seq anchor and its pattern into the cond_seq anchor. We'll
7836 // make sure the pattern knows how to jump correctly into the body if it
7837 // finds a match.
7838 for (size_t index = 0; index < node->conditions.size; index++) {
7839 const pm_node_t *condition = node->conditions.nodes[index];
7840 RUBY_ASSERT(PM_NODE_TYPE_P(condition, PM_IN_NODE));
7841
7842 const pm_in_node_t *in_node = (const pm_in_node_t *) condition;
7843 const pm_node_location_t in_location = PM_NODE_START_LOCATION(scope_node->parser, in_node);
7844 const pm_node_location_t pattern_location = PM_NODE_START_LOCATION(scope_node->parser, in_node->pattern);
7845
7846 if (branch_id) {
7847 PUSH_INSN(body_seq, in_location, putnil);
7848 }
7849
7850 LABEL *body_label = NEW_LABEL(in_location.line);
7851 PUSH_LABEL(body_seq, body_label);
7852 PUSH_INSN1(body_seq, in_location, adjuststack, INT2FIX(in_single_pattern ? 6 : 2));
7853
7854 // Establish branch coverage for the in clause.
7855 if (PM_BRANCH_COVERAGE_P(iseq)) {
7856 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));
7857 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "in", branches);
7858 }
7859
7860 if (in_node->statements != NULL) {
7861 PM_COMPILE_INTO_ANCHOR(body_seq, (const pm_node_t *) in_node->statements);
7862 }
7863 else if (!popped) {
7864 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7865 }
7866
7867 PUSH_INSNL(body_seq, in_location, jump, end_label);
7868 LABEL *next_pattern_label = NEW_LABEL(pattern_location.line);
7869
7870 PUSH_INSN(cond_seq, pattern_location, dup);
7871 pm_compile_pattern(iseq, scope_node, in_node->pattern, cond_seq, body_label, next_pattern_label, in_single_pattern, true, 2);
7872 PUSH_LABEL(cond_seq, next_pattern_label);
7873 LABEL_UNREMOVABLE(next_pattern_label);
7874 }
7875
7876 if (node->else_clause != NULL) {
7877 // If we have an `else` clause, then this becomes our fallback (and
7878 // there is no need to compile in code to potentially raise an
7879 // error).
7880 const pm_else_node_t *else_node = node->else_clause;
7881
7882 PUSH_LABEL(cond_seq, else_label);
7883 PUSH_INSN(cond_seq, *location, pop);
7884 PUSH_INSN(cond_seq, *location, pop);
7885
7886 // Establish branch coverage for the else clause.
7887 if (PM_BRANCH_COVERAGE_P(iseq)) {
7888 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));
7889 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7890 }
7891
7892 PM_COMPILE_INTO_ANCHOR(cond_seq, (const pm_node_t *) else_node);
7893 PUSH_INSNL(cond_seq, *location, jump, end_label);
7894 PUSH_INSN(cond_seq, *location, putnil);
7895 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7896 }
7897 else {
7898 // Otherwise, if we do not have an `else` clause, we will compile in
7899 // the code to handle raising an appropriate error.
7900 PUSH_LABEL(cond_seq, else_label);
7901
7902 // Establish branch coverage for the implicit else clause.
7903 add_trace_branch_coverage(iseq, cond_seq, &case_location, case_location.beg_pos.column, branch_id, "else", branches);
7904
7905 if (in_single_pattern) {
7906 pm_compile_pattern_error_handler(iseq, scope_node, (const pm_node_t *) node, cond_seq, end_label, popped);
7907 }
7908 else {
7909 PUSH_INSN1(cond_seq, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7910 PUSH_INSN1(cond_seq, *location, putobject, rb_eNoMatchingPatternError);
7911 PUSH_INSN1(cond_seq, *location, topn, INT2FIX(2));
7912 PUSH_SEND(cond_seq, *location, id_core_raise, INT2FIX(2));
7913
7914 PUSH_INSN1(cond_seq, *location, adjuststack, INT2FIX(3));
7915 if (!popped) PUSH_INSN(cond_seq, *location, putnil);
7916 PUSH_INSNL(cond_seq, *location, jump, end_label);
7917 PUSH_INSN1(cond_seq, *location, dupn, INT2FIX(1));
7918 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7919 }
7920 }
7921
7922 // At the end of all of this compilation, we will add the code for the
7923 // conditions first, then the various bodies, then mark the end of the
7924 // entire sequence with the end label.
7925 PUSH_SEQ(ret, cond_seq);
7926 PUSH_SEQ(ret, body_seq);
7927 PUSH_LABEL(ret, end_label);
7928}
7929
7930static inline void
7931pm_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)
7932{
7933 const rb_iseq_t *block = NULL;
7934 const rb_iseq_t *previous_block = NULL;
7935 LABEL *retry_label = NULL;
7936 LABEL *retry_end_l = NULL;
7937
7938 if (node->block != NULL) {
7939 previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
7940 ISEQ_COMPILE_DATA(iseq)->current_block = NULL;
7941
7942 retry_label = NEW_LABEL(location->line);
7943 retry_end_l = NEW_LABEL(location->line);
7944
7945 PUSH_LABEL(ret, retry_label);
7946 }
7947 else {
7948 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
7949 }
7950
7951 PUSH_INSN(ret, *location, putself);
7952 int flag = VM_CALL_ZSUPER | VM_CALL_SUPER | VM_CALL_FCALL;
7953
7954 if (node->block != NULL) {
7955 pm_scope_node_t next_scope_node;
7956 pm_scope_node_init((const pm_node_t *) node->block, &next_scope_node, scope_node);
7957
7958 ISEQ_COMPILE_DATA(iseq)->current_block = block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->line);
7959 pm_scope_node_destroy(&next_scope_node);
7960 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) block);
7961 }
7962
7963 DECL_ANCHOR(args);
7964
7965 struct rb_iseq_constant_body *const body = ISEQ_BODY(iseq);
7966 const rb_iseq_t *local_iseq = body->local_iseq;
7967 const struct rb_iseq_constant_body *const local_body = ISEQ_BODY(local_iseq);
7968
7969 int argc = 0;
7970 int depth = get_lvar_level(iseq);
7971
7972 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
7973 flag |= VM_CALL_FORWARDING;
7974 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
7975 PUSH_GETLOCAL(ret, *location, mult_local.index, mult_local.level);
7976
7977 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, 0, flag, NULL, block != NULL);
7978 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, block);
7979
7980 if (popped) PUSH_INSN(ret, *location, pop);
7981 if (node->block) {
7982 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
7983 }
7984 return;
7985 }
7986
7987 if (local_body->param.flags.has_lead) {
7988 /* required arguments */
7989 for (int i = 0; i < local_body->param.lead_num; i++) {
7990 int idx = local_body->local_table_size - i;
7991 PUSH_GETLOCAL(args, *location, idx, depth);
7992 }
7993 argc += local_body->param.lead_num;
7994 }
7995
7996 if (local_body->param.flags.has_opt) {
7997 /* optional arguments */
7998 for (int j = 0; j < local_body->param.opt_num; j++) {
7999 int idx = local_body->local_table_size - (argc + j);
8000 PUSH_GETLOCAL(args, *location, idx, depth);
8001 }
8002 argc += local_body->param.opt_num;
8003 }
8004
8005 if (local_body->param.flags.has_rest) {
8006 /* rest argument */
8007 int idx = local_body->local_table_size - local_body->param.rest_start;
8008 PUSH_GETLOCAL(args, *location, idx, depth);
8009 PUSH_INSN1(args, *location, splatarray, Qfalse);
8010
8011 argc = local_body->param.rest_start + 1;
8012 flag |= VM_CALL_ARGS_SPLAT;
8013 }
8014
8015 if (local_body->param.flags.has_post) {
8016 /* post arguments */
8017 int post_len = local_body->param.post_num;
8018 int post_start = local_body->param.post_start;
8019
8020 int j = 0;
8021 for (; j < post_len; j++) {
8022 int idx = local_body->local_table_size - (post_start + j);
8023 PUSH_GETLOCAL(args, *location, idx, depth);
8024 }
8025
8026 if (local_body->param.flags.has_rest) {
8027 // argc remains unchanged from rest branch
8028 PUSH_INSN1(args, *location, newarray, INT2FIX(j));
8029 PUSH_INSN(args, *location, concatarray);
8030 }
8031 else {
8032 argc = post_len + post_start;
8033 }
8034 }
8035
8036 const struct rb_iseq_param_keyword *const local_keyword = local_body->param.keyword;
8037 if (local_body->param.flags.has_kw) {
8038 int local_size = local_body->local_table_size;
8039 argc++;
8040
8041 PUSH_INSN1(args, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
8042
8043 if (local_body->param.flags.has_kwrest) {
8044 int idx = local_body->local_table_size - local_keyword->rest_start;
8045 PUSH_GETLOCAL(args, *location, idx, depth);
8046 RUBY_ASSERT(local_keyword->num > 0);
8047 PUSH_SEND(args, *location, rb_intern("dup"), INT2FIX(0));
8048 }
8049 else {
8050 PUSH_INSN1(args, *location, newhash, INT2FIX(0));
8051 }
8052 int i = 0;
8053 for (; i < local_keyword->num; ++i) {
8054 ID id = local_keyword->table[i];
8055 int idx = local_size - get_local_var_idx(local_iseq, id);
8056
8057 {
8058 VALUE operand = ID2SYM(id);
8059 PUSH_INSN1(args, *location, putobject, operand);
8060 }
8061
8062 PUSH_GETLOCAL(args, *location, idx, depth);
8063 }
8064
8065 PUSH_SEND(args, *location, id_core_hash_merge_ptr, INT2FIX(i * 2 + 1));
8066 flag |= VM_CALL_KW_SPLAT| VM_CALL_KW_SPLAT_MUT;
8067 }
8068 else if (local_body->param.flags.has_kwrest) {
8069 int idx = local_body->local_table_size - local_keyword->rest_start;
8070 PUSH_GETLOCAL(args, *location, idx, depth);
8071 argc++;
8072 flag |= VM_CALL_KW_SPLAT;
8073 }
8074
8075 PUSH_SEQ(ret, args);
8076
8077 {
8078 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flag, NULL, block != NULL);
8079 PUSH_INSN2(ret, *location, invokesuper, callinfo, block);
8080 }
8081
8082 if (node->block != NULL) {
8083 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8084 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, block, retry_end_l);
8085 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8086 }
8087
8088 if (popped) PUSH_INSN(ret, *location, pop);
8089}
8090
8091static inline void
8092pm_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)
8093{
8094 LABEL *matched_label = NEW_LABEL(location->line);
8095 LABEL *unmatched_label = NEW_LABEL(location->line);
8096 LABEL *done_label = NEW_LABEL(location->line);
8097
8098 // First, we're going to push a bunch of stuff onto the stack that is
8099 // going to serve as our scratch space.
8100 PUSH_INSN(ret, *location, putnil); // key error key
8101 PUSH_INSN(ret, *location, putnil); // key error matchee
8102 PUSH_INSN1(ret, *location, putobject, Qfalse); // key error?
8103 PUSH_INSN(ret, *location, putnil); // error string
8104 PUSH_INSN(ret, *location, putnil); // deconstruct cache
8105
8106 // Next we're going to compile the value expression such that it's on
8107 // the stack.
8108 PM_COMPILE_NOT_POPPED(node->value);
8109
8110 // Here we'll dup it so that it can be used for comparison, but also be
8111 // used for error handling.
8112 PUSH_INSN(ret, *location, dup);
8113
8114 // Next we'll compile the pattern. We indicate to the pm_compile_pattern
8115 // function that this is the only pattern that will be matched against
8116 // through the in_single_pattern parameter. We also indicate that the
8117 // value to compare against is 2 slots from the top of the stack (the
8118 // base_index parameter).
8119 pm_compile_pattern(iseq, scope_node, node->pattern, ret, matched_label, unmatched_label, true, true, 2);
8120
8121 // If the pattern did not match the value, then we're going to compile
8122 // in our error handler code. This will determine which error to raise
8123 // and raise it.
8124 PUSH_LABEL(ret, unmatched_label);
8125 pm_compile_pattern_error_handler(iseq, scope_node, (const pm_node_t *) node, ret, done_label, popped);
8126
8127 // If the pattern did match, we'll clean up the values we've pushed onto
8128 // the stack and then push nil onto the stack if it's not popped.
8129 PUSH_LABEL(ret, matched_label);
8130 PUSH_INSN1(ret, *location, adjuststack, INT2FIX(6));
8131 if (!popped) PUSH_INSN(ret, *location, putnil);
8132 PUSH_INSNL(ret, *location, jump, done_label);
8133
8134 PUSH_LABEL(ret, done_label);
8135}
8136
8137static inline void
8138pm_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)
8139{
8140 LABEL *fail_label = NEW_LABEL(location->line);
8141 LABEL *end_label = NEW_LABEL(location->line);
8142
8143 // First, we'll compile the call so that all of its instructions are
8144 // present. Then we'll compile all of the local variable targets.
8145 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->call);
8146
8147 // Now, check if the match was successful. If it was, then we'll
8148 // continue on and assign local variables. Otherwise we'll skip over the
8149 // assignment code.
8150 {
8151 VALUE operand = rb_id2sym(idBACKREF);
8152 PUSH_INSN1(ret, *location, getglobal, operand);
8153 }
8154
8155 PUSH_INSN(ret, *location, dup);
8156 PUSH_INSNL(ret, *location, branchunless, fail_label);
8157
8158 // If there's only a single local variable target, we can skip some of
8159 // the bookkeeping, so we'll put a special branch here.
8160 size_t targets_count = node->targets.size;
8161
8162 if (targets_count == 1) {
8163 const pm_node_t *target = node->targets.nodes[0];
8164 RUBY_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_TARGET_NODE));
8165
8166 const pm_local_variable_target_node_t *local_target = (const pm_local_variable_target_node_t *) target;
8167 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->name, local_target->depth);
8168
8169 {
8170 VALUE operand = rb_id2sym(pm_constant_id_lookup(scope_node, local_target->name));
8171 PUSH_INSN1(ret, *location, putobject, operand);
8172 }
8173
8174 PUSH_SEND(ret, *location, idAREF, INT2FIX(1));
8175 PUSH_LABEL(ret, fail_label);
8176 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8177 if (popped) PUSH_INSN(ret, *location, pop);
8178 return;
8179 }
8180
8181 DECL_ANCHOR(fail_anchor);
8182
8183 // Otherwise there is more than one local variable target, so we'll need
8184 // to do some bookkeeping.
8185 for (size_t targets_index = 0; targets_index < targets_count; targets_index++) {
8186 const pm_node_t *target = node->targets.nodes[targets_index];
8187 RUBY_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_TARGET_NODE));
8188
8189 const pm_local_variable_target_node_t *local_target = (const pm_local_variable_target_node_t *) target;
8190 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->name, local_target->depth);
8191
8192 if (((size_t) targets_index) < (targets_count - 1)) {
8193 PUSH_INSN(ret, *location, dup);
8194 }
8195
8196 {
8197 VALUE operand = rb_id2sym(pm_constant_id_lookup(scope_node, local_target->name));
8198 PUSH_INSN1(ret, *location, putobject, operand);
8199 }
8200
8201 PUSH_SEND(ret, *location, idAREF, INT2FIX(1));
8202 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8203
8204 PUSH_INSN(fail_anchor, *location, putnil);
8205 PUSH_SETLOCAL(fail_anchor, *location, index.index, index.level);
8206 }
8207
8208 // Since we matched successfully, now we'll jump to the end.
8209 PUSH_INSNL(ret, *location, jump, end_label);
8210
8211 // In the case that the match failed, we'll loop through each local
8212 // variable target and set all of them to `nil`.
8213 PUSH_LABEL(ret, fail_label);
8214 PUSH_INSN(ret, *location, pop);
8215 PUSH_SEQ(ret, fail_anchor);
8216
8217 // Finally, we can push the end label for either case.
8218 PUSH_LABEL(ret, end_label);
8219 if (popped) PUSH_INSN(ret, *location, pop);
8220}
8221
8222static inline void
8223pm_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)
8224{
8225 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
8226 LABEL *splabel = NEW_LABEL(0);
8227 PUSH_LABEL(ret, splabel);
8228
8229 if (node->arguments) {
8230 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8231 }
8232 else {
8233 PUSH_INSN(ret, *location, putnil);
8234 }
8235 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8236
8237 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8238 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8239
8240 PUSH_ADJUST_RESTORE(ret, splabel);
8241 if (!popped) PUSH_INSN(ret, *location, putnil);
8242 }
8243 else if (ISEQ_COMPILE_DATA(iseq)->end_label && can_add_ensure_iseq(iseq)) {
8244 LABEL *splabel = NEW_LABEL(0);
8245
8246 PUSH_LABEL(ret, splabel);
8247 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8248
8249 if (node->arguments != NULL) {
8250 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8251 }
8252 else {
8253 PUSH_INSN(ret, *location, putnil);
8254 }
8255
8256 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8257 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
8258 PUSH_ADJUST_RESTORE(ret, splabel);
8259 splabel->unremovable = FALSE;
8260
8261 if (!popped) PUSH_INSN(ret, *location, putnil);
8262 }
8263 else {
8264 const rb_iseq_t *ip = iseq;
8265 unsigned long throw_flag = 0;
8266
8267 while (ip) {
8268 if (!ISEQ_COMPILE_DATA(ip)) {
8269 ip = 0;
8270 break;
8271 }
8272
8273 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
8274 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8275 /* while loop */
8276 break;
8277 }
8278 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
8279 break;
8280 }
8281 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
8282 COMPILE_ERROR(iseq, location->line, "Invalid next");
8283 return;
8284 }
8285
8286 ip = ISEQ_BODY(ip)->parent_iseq;
8287 }
8288
8289 if (ip != 0) {
8290 if (node->arguments) {
8291 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8292 }
8293 else {
8294 PUSH_INSN(ret, *location, putnil);
8295 }
8296
8297 PUSH_INSN1(ret, *location, throw, INT2FIX(throw_flag | TAG_NEXT));
8298 if (popped) PUSH_INSN(ret, *location, pop);
8299 }
8300 else {
8301 COMPILE_ERROR(iseq, location->line, "Invalid next");
8302 }
8303 }
8304}
8305
8306static inline void
8307pm_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)
8308{
8309 if (ISEQ_COMPILE_DATA(iseq)->redo_label && can_add_ensure_iseq(iseq)) {
8310 LABEL *splabel = NEW_LABEL(0);
8311
8312 PUSH_LABEL(ret, splabel);
8313 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8314 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8315
8316 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->redo_label);
8317 PUSH_ADJUST_RESTORE(ret, splabel);
8318 if (!popped) PUSH_INSN(ret, *location, putnil);
8319 }
8320 else if (ISEQ_BODY(iseq)->type != ISEQ_TYPE_EVAL && ISEQ_COMPILE_DATA(iseq)->start_label && can_add_ensure_iseq(iseq)) {
8321 LABEL *splabel = NEW_LABEL(0);
8322
8323 PUSH_LABEL(ret, splabel);
8324 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8325 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8326
8327 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8328 PUSH_ADJUST_RESTORE(ret, splabel);
8329 if (!popped) PUSH_INSN(ret, *location, putnil);
8330 }
8331 else {
8332 const rb_iseq_t *ip = iseq;
8333
8334 while (ip) {
8335 if (!ISEQ_COMPILE_DATA(ip)) {
8336 ip = 0;
8337 break;
8338 }
8339
8340 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8341 break;
8342 }
8343 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
8344 break;
8345 }
8346 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
8347 COMPILE_ERROR(iseq, location->line, "Invalid redo");
8348 return;
8349 }
8350
8351 ip = ISEQ_BODY(ip)->parent_iseq;
8352 }
8353
8354 if (ip != 0) {
8355 PUSH_INSN(ret, *location, putnil);
8356 PUSH_INSN1(ret, *location, throw, INT2FIX(VM_THROW_NO_ESCAPE_FLAG | TAG_REDO));
8357 if (popped) PUSH_INSN(ret, *location, pop);
8358 }
8359 else {
8360 COMPILE_ERROR(iseq, location->line, "Invalid redo");
8361 }
8362 }
8363}
8364
8365static inline void
8366pm_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)
8367{
8368 iseq_set_exception_local_table(iseq);
8369
8370 // First, establish the labels that we need to be able to jump to within
8371 // this compilation block.
8372 LABEL *exception_match_label = NEW_LABEL(location->line);
8373 LABEL *rescue_end_label = NEW_LABEL(location->line);
8374
8375 // Next, compile each of the exceptions that we're going to be
8376 // handling. For each one, we'll add instructions to check if the
8377 // exception matches the raised one, and if it does then jump to the
8378 // exception_match_label label. Otherwise it will fall through to the
8379 // subsequent check. If there are no exceptions, we'll only check
8380 // StandardError.
8381 const pm_node_list_t *exceptions = &node->exceptions;
8382
8383 if (exceptions->size > 0) {
8384 for (size_t index = 0; index < exceptions->size; index++) {
8385 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8386 PM_COMPILE(exceptions->nodes[index]);
8387 int checkmatch_flags = VM_CHECKMATCH_TYPE_RESCUE;
8388 if (PM_NODE_TYPE_P(exceptions->nodes[index], PM_SPLAT_NODE)) {
8389 checkmatch_flags |= VM_CHECKMATCH_ARRAY;
8390 }
8391 PUSH_INSN1(ret, *location, checkmatch, INT2FIX(checkmatch_flags));
8392 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8393 }
8394 }
8395 else {
8396 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8397 PUSH_INSN1(ret, *location, putobject, rb_eStandardError);
8398 PUSH_INSN1(ret, *location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
8399 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8400 }
8401
8402 // If none of the exceptions that we are matching against matched, then
8403 // we'll jump straight to the rescue_end_label label.
8404 PUSH_INSNL(ret, *location, jump, rescue_end_label);
8405
8406 // Here we have the exception_match_label, which is where the
8407 // control-flow goes in the case that one of the exceptions matched.
8408 // Here we will compile the instructions to handle the exception.
8409 PUSH_LABEL(ret, exception_match_label);
8410 PUSH_TRACE(ret, RUBY_EVENT_RESCUE);
8411
8412 // If we have a reference to the exception, then we'll compile the write
8413 // into the instruction sequence. This can look quite different
8414 // depending on the kind of write being performed.
8415 if (node->reference) {
8416 DECL_ANCHOR(writes);
8417 DECL_ANCHOR(cleanup);
8418
8419 pm_compile_target_node(iseq, node->reference, ret, writes, cleanup, scope_node, NULL);
8420 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8421
8422 PUSH_SEQ(ret, writes);
8423 PUSH_SEQ(ret, cleanup);
8424 }
8425
8426 // If we have statements to execute, we'll compile them here. Otherwise
8427 // we'll push nil onto the stack.
8428 if (node->statements != NULL) {
8429 // We'll temporarily remove the end_label location from the iseq
8430 // when compiling the statements so that next/redo statements
8431 // inside the body will throw to the correct place instead of
8432 // jumping straight to the end of this iseq
8433 LABEL *prev_end = ISEQ_COMPILE_DATA(iseq)->end_label;
8434 ISEQ_COMPILE_DATA(iseq)->end_label = NULL;
8435
8436 PM_COMPILE((const pm_node_t *) node->statements);
8437
8438 // Now restore the end_label
8439 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end;
8440 }
8441 else {
8442 PUSH_INSN(ret, *location, putnil);
8443 }
8444
8445 PUSH_INSN(ret, *location, leave);
8446
8447 // Here we'll insert the rescue_end_label label, which is jumped to if
8448 // none of the exceptions matched. It will cause the control-flow to
8449 // either jump to the next rescue clause or it will fall through to the
8450 // subsequent instruction returning the raised error.
8451 PUSH_LABEL(ret, rescue_end_label);
8452 if (node->subsequent != NULL) {
8453 PM_COMPILE((const pm_node_t *) node->subsequent);
8454 }
8455 else {
8456 PUSH_GETLOCAL(ret, *location, 1, 0);
8457 }
8458}
8459
8460static inline void
8461pm_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)
8462{
8463 const pm_arguments_node_t *arguments = node->arguments;
8464 enum rb_iseq_type type = ISEQ_BODY(iseq)->type;
8465 LABEL *splabel = 0;
8466
8467 const rb_iseq_t *parent_iseq = iseq;
8468 enum rb_iseq_type parent_type = ISEQ_BODY(parent_iseq)->type;
8469 while (parent_type == ISEQ_TYPE_RESCUE || parent_type == ISEQ_TYPE_ENSURE) {
8470 if (!(parent_iseq = ISEQ_BODY(parent_iseq)->parent_iseq)) break;
8471 parent_type = ISEQ_BODY(parent_iseq)->type;
8472 }
8473
8474 switch (parent_type) {
8475 case ISEQ_TYPE_TOP:
8476 case ISEQ_TYPE_MAIN:
8477 if (arguments) {
8478 rb_warn("argument of top-level return is ignored");
8479 }
8480 if (parent_iseq == iseq) {
8481 type = ISEQ_TYPE_METHOD;
8482 }
8483 break;
8484 default:
8485 break;
8486 }
8487
8488 if (type == ISEQ_TYPE_METHOD) {
8489 splabel = NEW_LABEL(0);
8490 PUSH_LABEL(ret, splabel);
8491 PUSH_ADJUST(ret, *location, 0);
8492 }
8493
8494 if (arguments != NULL) {
8495 PM_COMPILE_NOT_POPPED((const pm_node_t *) arguments);
8496 }
8497 else {
8498 PUSH_INSN(ret, *location, putnil);
8499 }
8500
8501 if (type == ISEQ_TYPE_METHOD && can_add_ensure_iseq(iseq)) {
8502 pm_add_ensure_iseq(ret, iseq, 1, scope_node);
8503 PUSH_TRACE(ret, RUBY_EVENT_RETURN);
8504 PUSH_INSN(ret, *location, leave);
8505 PUSH_ADJUST_RESTORE(ret, splabel);
8506 if (!popped) PUSH_INSN(ret, *location, putnil);
8507 }
8508 else {
8509 PUSH_INSN1(ret, *location, throw, INT2FIX(TAG_RETURN));
8510 if (popped) PUSH_INSN(ret, *location, pop);
8511 }
8512}
8513
8514static inline void
8515pm_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)
8516{
8517 DECL_ANCHOR(args);
8518
8519 LABEL *retry_label = NEW_LABEL(location->line);
8520 LABEL *retry_end_l = NEW_LABEL(location->line);
8521
8522 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
8523 const rb_iseq_t *current_block;
8524 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NULL;
8525
8526 PUSH_LABEL(ret, retry_label);
8527 PUSH_INSN(ret, *location, putself);
8528
8529 int flags = 0;
8530 struct rb_callinfo_kwarg *keywords = NULL;
8531 int argc = pm_setup_args(node->arguments, node->block, &flags, &keywords, iseq, ret, scope_node, location);
8532 bool is_forwardable = (node->arguments != NULL) && PM_NODE_FLAG_P(node->arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING);
8533 flags |= VM_CALL_SUPER | VM_CALL_FCALL;
8534
8535 if (node->block && PM_NODE_TYPE_P(node->block, PM_BLOCK_NODE)) {
8536 pm_scope_node_t next_scope_node;
8537 pm_scope_node_init(node->block, &next_scope_node, scope_node);
8538
8539 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->line);
8540 pm_scope_node_destroy(&next_scope_node);
8541 }
8542
8543 if (!node->block) {
8544 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8545 }
8546
8547 if ((flags & VM_CALL_ARGS_BLOCKARG) && (flags & VM_CALL_KW_SPLAT) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
8548 PUSH_INSN(args, *location, splatkw);
8549 }
8550
8551 PUSH_SEQ(ret, args);
8552 if (is_forwardable && ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
8553 flags |= VM_CALL_FORWARDING;
8554
8555 {
8556 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8557 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, current_block);
8558 }
8559 }
8560 else {
8561 {
8562 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8563 PUSH_INSN2(ret, *location, invokesuper, callinfo, current_block);
8564 }
8565
8566 }
8567
8568 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8569
8570 if (popped) PUSH_INSN(ret, *location, pop);
8571 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8572 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, current_block, retry_end_l);
8573}
8574
8575static inline void
8576pm_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)
8577{
8578 switch (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->type) {
8579 case ISEQ_TYPE_TOP:
8580 case ISEQ_TYPE_MAIN:
8581 case ISEQ_TYPE_CLASS:
8582 COMPILE_ERROR(iseq, location->line, "Invalid yield");
8583 return;
8584 default: /* valid */;
8585 }
8586
8587 int argc = 0;
8588 int flags = 0;
8589 struct rb_callinfo_kwarg *keywords = NULL;
8590
8591 if (node->arguments) {
8592 argc = pm_setup_args(node->arguments, NULL, &flags, &keywords, iseq, ret, scope_node, location);
8593 }
8594
8595 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, FALSE);
8596 PUSH_INSN1(ret, *location, invokeblock, callinfo);
8597
8598 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8599 if (popped) PUSH_INSN(ret, *location, pop);
8600
8601 int level = 0;
8602 for (const rb_iseq_t *tmp_iseq = iseq; tmp_iseq != ISEQ_BODY(iseq)->local_iseq; level++) {
8603 tmp_iseq = ISEQ_BODY(tmp_iseq)->parent_iseq;
8604 }
8605
8606 if (level > 0) access_outer_variables(iseq, level, rb_intern("yield"), true);
8607}
8608
8619static void
8620pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8621{
8622 const pm_parser_t *parser = scope_node->parser;
8623 const pm_node_location_t location = PM_NODE_START_LOCATION(parser, node);
8624 int lineno = (int) location.line;
8625
8626 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)) {
8627 // If this node is a begin node and it has empty statements and also
8628 // has a rescue clause, then the other parser considers it as
8629 // starting on the same line as the rescue, as opposed to the
8630 // location of the begin keyword. We replicate that behavior here.
8631 lineno = (int) PM_NODE_START_LINE_COLUMN(parser, ((const pm_begin_node_t *) node)->rescue_clause).line;
8632 }
8633
8634 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_NEWLINE) && ISEQ_COMPILE_DATA(iseq)->last_line != lineno) {
8635 // If this node has the newline flag set and it is on a new line
8636 // from the previous nodes that have been compiled for this ISEQ,
8637 // then we need to emit a newline event.
8638 int event = RUBY_EVENT_LINE;
8639
8640 ISEQ_COMPILE_DATA(iseq)->last_line = lineno;
8641 if (lineno > 0 && ISEQ_COVERAGE(iseq) && ISEQ_LINE_COVERAGE(iseq)) {
8642 event |= RUBY_EVENT_COVERAGE_LINE;
8643 }
8644 PUSH_TRACE(ret, event);
8645 }
8646
8647 switch (PM_NODE_TYPE(node)) {
8648 case PM_ALIAS_GLOBAL_VARIABLE_NODE:
8649 // alias $foo $bar
8650 // ^^^^^^^^^^^^^^^
8651 pm_compile_alias_global_variable_node(iseq, (const pm_alias_global_variable_node_t *) node, &location, ret, popped, scope_node);
8652 return;
8653 case PM_ALIAS_METHOD_NODE:
8654 // alias foo bar
8655 // ^^^^^^^^^^^^^
8656 pm_compile_alias_method_node(iseq, (const pm_alias_method_node_t *) node, &location, ret, popped, scope_node);
8657 return;
8658 case PM_AND_NODE:
8659 // a and b
8660 // ^^^^^^^
8661 pm_compile_and_node(iseq, (const pm_and_node_t *) node, &location, ret, popped, scope_node);
8662 return;
8663 case PM_ARGUMENTS_NODE: {
8664 // break foo
8665 // ^^^
8666 //
8667 // These are ArgumentsNodes that are not compiled directly by their
8668 // parent call nodes, used in the cases of NextNodes, ReturnNodes, and
8669 // BreakNodes. They can create an array like ArrayNode.
8670 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
8671 const pm_node_list_t *elements = &cast->arguments;
8672
8673 if (elements->size == 1) {
8674 // If we are only returning a single element through one of the jump
8675 // nodes, then we will only compile that node directly.
8676 PM_COMPILE(elements->nodes[0]);
8677 }
8678 else {
8679 pm_compile_array_node(iseq, (const pm_node_t *) cast, elements, &location, ret, popped, scope_node);
8680 }
8681 return;
8682 }
8683 case PM_ARRAY_NODE: {
8684 // [foo, bar, baz]
8685 // ^^^^^^^^^^^^^^^
8686 const pm_array_node_t *cast = (const pm_array_node_t *) node;
8687 pm_compile_array_node(iseq, (const pm_node_t *) cast, &cast->elements, &location, ret, popped, scope_node);
8688 return;
8689 }
8690 case PM_ASSOC_NODE: {
8691 // { foo: 1 }
8692 // ^^^^^^
8693 //
8694 // foo(bar: 1)
8695 // ^^^^^^
8696 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
8697
8698 PM_COMPILE(cast->key);
8699 PM_COMPILE(cast->value);
8700
8701 return;
8702 }
8703 case PM_ASSOC_SPLAT_NODE: {
8704 // { **foo }
8705 // ^^^^^
8706 //
8707 // def foo(**); bar(**); end
8708 // ^^
8709 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
8710
8711 if (cast->value != NULL) {
8712 PM_COMPILE(cast->value);
8713 }
8714 else if (!popped) {
8715 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
8716 PUSH_GETLOCAL(ret, location, index.index, index.level);
8717 }
8718
8719 return;
8720 }
8721 case PM_BACK_REFERENCE_READ_NODE: {
8722 // $+
8723 // ^^
8724 if (!popped) {
8725 const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
8726 VALUE backref = pm_compile_back_reference_ref(cast);
8727
8728 PUSH_INSN2(ret, location, getspecial, INT2FIX(1), backref);
8729 }
8730 return;
8731 }
8732 case PM_BEGIN_NODE: {
8733 // begin end
8734 // ^^^^^^^^^
8735 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
8736
8737 if (cast->ensure_clause) {
8738 // Compiling the ensure clause will compile the rescue clause (if
8739 // there is one), which will compile the begin statements.
8740 pm_compile_ensure(iseq, cast, &location, ret, popped, scope_node);
8741 }
8742 else if (cast->rescue_clause) {
8743 // Compiling rescue will compile begin statements (if applicable).
8744 pm_compile_rescue(iseq, cast, &location, ret, popped, scope_node);
8745 }
8746 else {
8747 // If there is neither ensure or rescue, the just compile the
8748 // statements.
8749 if (cast->statements != NULL) {
8750 PM_COMPILE((const pm_node_t *) cast->statements);
8751 }
8752 else if (!popped) {
8753 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
8754 }
8755 }
8756 return;
8757 }
8758 case PM_BLOCK_ARGUMENT_NODE: {
8759 // foo(&bar)
8760 // ^^^^
8761 const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
8762
8763 if (cast->expression != NULL) {
8764 PM_COMPILE(cast->expression);
8765 }
8766 else {
8767 // If there's no expression, this must be block forwarding.
8768 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
8769 PUSH_INSN2(ret, location, getblockparamproxy, INT2FIX(local_index.index + VM_ENV_DATA_SIZE - 1), INT2FIX(local_index.level));
8770 }
8771 return;
8772 }
8773 case PM_BREAK_NODE:
8774 // break
8775 // ^^^^^
8776 //
8777 // break foo
8778 // ^^^^^^^^^
8779 pm_compile_break_node(iseq, (const pm_break_node_t *) node, &location, ret, popped, scope_node);
8780 return;
8781 case PM_CALL_NODE:
8782 // foo
8783 // ^^^
8784 //
8785 // foo.bar
8786 // ^^^^^^^
8787 //
8788 // foo.bar() {}
8789 // ^^^^^^^^^^^^
8790 pm_compile_call_node(iseq, (const pm_call_node_t *) node, ret, popped, scope_node);
8791 return;
8792 case PM_CALL_AND_WRITE_NODE: {
8793 // foo.bar &&= baz
8794 // ^^^^^^^^^^^^^^^
8795 const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
8796 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);
8797 return;
8798 }
8799 case PM_CALL_OR_WRITE_NODE: {
8800 // foo.bar ||= baz
8801 // ^^^^^^^^^^^^^^^
8802 const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
8803 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);
8804 return;
8805 }
8806 case PM_CALL_OPERATOR_WRITE_NODE:
8807 // foo.bar += baz
8808 // ^^^^^^^^^^^^^^^
8809 //
8810 // Call operator writes occur when you have a call node on the left-hand
8811 // side of a write operator that is not `=`. As an example,
8812 // `foo.bar *= 1`. This breaks down to caching the receiver on the
8813 // stack and then performing three method calls, one to read the value,
8814 // one to compute the result, and one to write the result back to the
8815 // receiver.
8816 pm_compile_call_operator_write_node(iseq, (const pm_call_operator_write_node_t *) node, &location, ret, popped, scope_node);
8817 return;
8818 case PM_CASE_NODE:
8819 // case foo; when bar; end
8820 // ^^^^^^^^^^^^^^^^^^^^^^^
8821 pm_compile_case_node(iseq, (const pm_case_node_t *) node, &location, ret, popped, scope_node);
8822 return;
8823 case PM_CASE_MATCH_NODE:
8824 // case foo; in bar; end
8825 // ^^^^^^^^^^^^^^^^^^^^^
8826 //
8827 // If you use the `case` keyword to create a case match node, it will
8828 // match against all of the `in` clauses until it finds one that
8829 // matches. If it doesn't find one, it can optionally fall back to an
8830 // `else` clause. If none is present and a match wasn't found, it will
8831 // raise an appropriate error.
8832 pm_compile_case_match_node(iseq, (const pm_case_match_node_t *) node, &location, ret, popped, scope_node);
8833 return;
8834 case PM_CLASS_NODE: {
8835 // class Foo; end
8836 // ^^^^^^^^^^^^^^
8837 const pm_class_node_t *cast = (const pm_class_node_t *) node;
8838
8839 ID class_id = pm_constant_id_lookup(scope_node, cast->name);
8840 VALUE class_name = rb_str_freeze(rb_sprintf("<class:%"PRIsVALUE">", rb_id2str(class_id)));
8841
8842 pm_scope_node_t next_scope_node;
8843 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
8844
8845 const rb_iseq_t *class_iseq = NEW_CHILD_ISEQ(&next_scope_node, class_name, ISEQ_TYPE_CLASS, location.line);
8846 pm_scope_node_destroy(&next_scope_node);
8847
8848 // TODO: Once we merge constant path nodes correctly, fix this flag
8849 const int flags = VM_DEFINECLASS_TYPE_CLASS |
8850 (cast->superclass ? VM_DEFINECLASS_FLAG_HAS_SUPERCLASS : 0) |
8851 pm_compile_class_path(iseq, cast->constant_path, &location, ret, false, scope_node);
8852
8853 if (cast->superclass) {
8854 PM_COMPILE_NOT_POPPED(cast->superclass);
8855 }
8856 else {
8857 PUSH_INSN(ret, location, putnil);
8858 }
8859
8860 {
8861 VALUE operand = ID2SYM(class_id);
8862 PUSH_INSN3(ret, location, defineclass, operand, class_iseq, INT2FIX(flags));
8863 }
8864 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)class_iseq);
8865
8866 if (popped) PUSH_INSN(ret, location, pop);
8867 return;
8868 }
8869 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
8870 // @@foo &&= bar
8871 // ^^^^^^^^^^^^^
8872 const pm_class_variable_and_write_node_t *cast = (const pm_class_variable_and_write_node_t *) node;
8873 LABEL *end_label = NEW_LABEL(location.line);
8874
8875 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8876 VALUE name = ID2SYM(name_id);
8877
8878 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8879 if (!popped) PUSH_INSN(ret, location, dup);
8880
8881 PUSH_INSNL(ret, location, branchunless, end_label);
8882 if (!popped) PUSH_INSN(ret, location, pop);
8883
8884 PM_COMPILE_NOT_POPPED(cast->value);
8885 if (!popped) PUSH_INSN(ret, location, dup);
8886
8887 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8888 PUSH_LABEL(ret, end_label);
8889
8890 return;
8891 }
8892 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
8893 // @@foo += bar
8894 // ^^^^^^^^^^^^
8895 const pm_class_variable_operator_write_node_t *cast = (const pm_class_variable_operator_write_node_t *) node;
8896
8897 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8898 VALUE name = ID2SYM(name_id);
8899
8900 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8901 PM_COMPILE_NOT_POPPED(cast->value);
8902
8903 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
8904 int flags = VM_CALL_ARGS_SIMPLE;
8905 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
8906
8907 if (!popped) PUSH_INSN(ret, location, dup);
8908 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8909
8910 return;
8911 }
8912 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
8913 // @@foo ||= bar
8914 // ^^^^^^^^^^^^^
8915 const pm_class_variable_or_write_node_t *cast = (const pm_class_variable_or_write_node_t *) node;
8916 LABEL *end_label = NEW_LABEL(location.line);
8917 LABEL *start_label = NEW_LABEL(location.line);
8918
8919 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8920 VALUE name = ID2SYM(name_id);
8921
8922 PUSH_INSN(ret, location, putnil);
8923 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CVAR), name, Qtrue);
8924 PUSH_INSNL(ret, location, branchunless, start_label);
8925
8926 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8927 if (!popped) PUSH_INSN(ret, location, dup);
8928
8929 PUSH_INSNL(ret, location, branchif, end_label);
8930 if (!popped) PUSH_INSN(ret, location, pop);
8931
8932 PUSH_LABEL(ret, start_label);
8933 PM_COMPILE_NOT_POPPED(cast->value);
8934 if (!popped) PUSH_INSN(ret, location, dup);
8935
8936 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8937 PUSH_LABEL(ret, end_label);
8938
8939 return;
8940 }
8941 case PM_CLASS_VARIABLE_READ_NODE: {
8942 // @@foo
8943 // ^^^^^
8944 if (!popped) {
8945 const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
8946 ID name = pm_constant_id_lookup(scope_node, cast->name);
8947 PUSH_INSN2(ret, location, getclassvariable, ID2SYM(name), get_cvar_ic_value(iseq, name));
8948 }
8949 return;
8950 }
8951 case PM_CLASS_VARIABLE_WRITE_NODE: {
8952 // @@foo = 1
8953 // ^^^^^^^^^
8954 const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
8955 PM_COMPILE_NOT_POPPED(cast->value);
8956 if (!popped) PUSH_INSN(ret, location, dup);
8957
8958 ID name = pm_constant_id_lookup(scope_node, cast->name);
8959 PUSH_INSN2(ret, location, setclassvariable, ID2SYM(name), get_cvar_ic_value(iseq, name));
8960
8961 return;
8962 }
8963 case PM_CONSTANT_PATH_NODE: {
8964 // Foo::Bar
8965 // ^^^^^^^^
8966 VALUE parts;
8967
8968 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache && ((parts = pm_constant_path_parts(node, scope_node)) != Qnil)) {
8969 ISEQ_BODY(iseq)->ic_size++;
8970 RB_OBJ_SET_SHAREABLE(parts);
8971 PUSH_INSN1(ret, location, opt_getconstant_path, parts);
8972 }
8973 else {
8974 DECL_ANCHOR(prefix);
8975 DECL_ANCHOR(body);
8976
8977 pm_compile_constant_path(iseq, node, prefix, body, popped, scope_node);
8978 if (LIST_INSN_SIZE_ZERO(prefix)) {
8979 PUSH_INSN(ret, location, putnil);
8980 }
8981 else {
8982 PUSH_SEQ(ret, prefix);
8983 }
8984
8985 PUSH_SEQ(ret, body);
8986 }
8987
8988 if (popped) PUSH_INSN(ret, location, pop);
8989 return;
8990 }
8991 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
8992 // Foo::Bar &&= baz
8993 // ^^^^^^^^^^^^^^^^
8994 const pm_constant_path_and_write_node_t *cast = (const pm_constant_path_and_write_node_t *) node;
8995 pm_compile_constant_path_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8996 return;
8997 }
8998 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
8999 // Foo::Bar ||= baz
9000 // ^^^^^^^^^^^^^^^^
9001 const pm_constant_path_or_write_node_t *cast = (const pm_constant_path_or_write_node_t *) node;
9002 pm_compile_constant_path_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9003 return;
9004 }
9005 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
9006 // Foo::Bar += baz
9007 // ^^^^^^^^^^^^^^^
9008 const pm_constant_path_operator_write_node_t *cast = (const pm_constant_path_operator_write_node_t *) node;
9009 pm_compile_constant_path_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9010 return;
9011 }
9012 case PM_CONSTANT_PATH_WRITE_NODE: {
9013 // Foo::Bar = 1
9014 // ^^^^^^^^^^^^
9015 const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
9016 pm_compile_constant_path_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9017 return;
9018 }
9019 case PM_CONSTANT_READ_NODE: {
9020 // Foo
9021 // ^^^
9022 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
9023 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9024
9025 pm_compile_constant_read(iseq, name, &cast->base.location, location.node_id, ret, scope_node);
9026 if (popped) PUSH_INSN(ret, location, pop);
9027
9028 return;
9029 }
9030 case PM_CONSTANT_AND_WRITE_NODE: {
9031 // Foo &&= bar
9032 // ^^^^^^^^^^^
9033 const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
9034 pm_compile_constant_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9035 return;
9036 }
9037 case PM_CONSTANT_OR_WRITE_NODE: {
9038 // Foo ||= bar
9039 // ^^^^^^^^^^^
9040 const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
9041 pm_compile_constant_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9042 return;
9043 }
9044 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
9045 // Foo += bar
9046 // ^^^^^^^^^^
9047 const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
9048 pm_compile_constant_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9049 return;
9050 }
9051 case PM_CONSTANT_WRITE_NODE: {
9052 // Foo = 1
9053 // ^^^^^^^
9054 const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
9055 pm_compile_constant_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9056 return;
9057 }
9058 case PM_DEF_NODE: {
9059 // def foo; end
9060 // ^^^^^^^^^^^^
9061 //
9062 // def self.foo; end
9063 // ^^^^^^^^^^^^^^^^^
9064 const pm_def_node_t *cast = (const pm_def_node_t *) node;
9065 ID method_name = pm_constant_id_lookup(scope_node, cast->name);
9066
9067 pm_scope_node_t next_scope_node;
9068 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9069
9070 rb_iseq_t *method_iseq = NEW_ISEQ(&next_scope_node, rb_id2str(method_name), ISEQ_TYPE_METHOD, location.line);
9071 pm_scope_node_destroy(&next_scope_node);
9072
9073 if (cast->receiver) {
9074 PM_COMPILE_NOT_POPPED(cast->receiver);
9075 PUSH_INSN2(ret, location, definesmethod, ID2SYM(method_name), method_iseq);
9076 }
9077 else {
9078 PUSH_INSN2(ret, location, definemethod, ID2SYM(method_name), method_iseq);
9079 }
9080 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) method_iseq);
9081
9082 if (!popped) {
9083 PUSH_INSN1(ret, location, putobject, ID2SYM(method_name));
9084 }
9085
9086 return;
9087 }
9088 case PM_DEFINED_NODE: {
9089 // defined?(a)
9090 // ^^^^^^^^^^^
9091 const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
9092 pm_compile_defined_expr(iseq, cast->value, &location, ret, popped, scope_node, false);
9093 return;
9094 }
9095 case PM_EMBEDDED_STATEMENTS_NODE: {
9096 // "foo #{bar}"
9097 // ^^^^^^
9098 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
9099
9100 if (cast->statements != NULL) {
9101 PM_COMPILE((const pm_node_t *) (cast->statements));
9102 }
9103 else {
9104 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9105 }
9106
9107 if (popped) PUSH_INSN(ret, location, pop);
9108 return;
9109 }
9110 case PM_EMBEDDED_VARIABLE_NODE: {
9111 // "foo #@bar"
9112 // ^^^^^
9113 const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
9114 PM_COMPILE(cast->variable);
9115 return;
9116 }
9117 case PM_FALSE_NODE: {
9118 // false
9119 // ^^^^^
9120 if (!popped) {
9121 PUSH_INSN1(ret, location, putobject, Qfalse);
9122 }
9123 return;
9124 }
9125 case PM_ENSURE_NODE: {
9126 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
9127
9128 if (cast->statements != NULL) {
9129 PM_COMPILE((const pm_node_t *) cast->statements);
9130 }
9131
9132 return;
9133 }
9134 case PM_ELSE_NODE: {
9135 // if foo then bar else baz end
9136 // ^^^^^^^^^^^^
9137 const pm_else_node_t *cast = (const pm_else_node_t *) node;
9138
9139 if (cast->statements != NULL) {
9140 PM_COMPILE((const pm_node_t *) cast->statements);
9141 }
9142 else if (!popped) {
9143 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9144 }
9145
9146 return;
9147 }
9148 case PM_FLIP_FLOP_NODE: {
9149 // if foo .. bar; end
9150 // ^^^^^^^^^^
9151 const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
9152
9153 LABEL *final_label = NEW_LABEL(location.line);
9154 LABEL *then_label = NEW_LABEL(location.line);
9155 LABEL *else_label = NEW_LABEL(location.line);
9156
9157 pm_compile_flip_flop(cast, else_label, then_label, iseq, location.line, ret, popped, scope_node);
9158
9159 PUSH_LABEL(ret, then_label);
9160 PUSH_INSN1(ret, location, putobject, Qtrue);
9161 PUSH_INSNL(ret, location, jump, final_label);
9162 PUSH_LABEL(ret, else_label);
9163 PUSH_INSN1(ret, location, putobject, Qfalse);
9164 PUSH_LABEL(ret, final_label);
9165
9166 return;
9167 }
9168 case PM_FLOAT_NODE: {
9169 // 1.0
9170 // ^^^
9171 if (!popped) {
9172 VALUE operand = parse_float((const pm_float_node_t *) node);
9173 PUSH_INSN1(ret, location, putobject, operand);
9174 }
9175 return;
9176 }
9177 case PM_FOR_NODE: {
9178 // for foo in bar do end
9179 // ^^^^^^^^^^^^^^^^^^^^^
9180 const pm_for_node_t *cast = (const pm_for_node_t *) node;
9181
9182 LABEL *retry_label = NEW_LABEL(location.line);
9183 LABEL *retry_end_l = NEW_LABEL(location.line);
9184
9185 // First, compile the collection that we're going to be iterating over.
9186 PUSH_LABEL(ret, retry_label);
9187 PM_COMPILE_NOT_POPPED(cast->collection);
9188
9189 // Next, create the new scope that is going to contain the block that
9190 // will be passed to the each method.
9191 pm_scope_node_t next_scope_node;
9192 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9193
9194 const rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location.line);
9195 pm_scope_node_destroy(&next_scope_node);
9196
9197 const rb_iseq_t *prev_block = ISEQ_COMPILE_DATA(iseq)->current_block;
9198 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
9199
9200 // Now, create the method call to each that will be used to iterate over
9201 // the collection, and pass the newly created iseq as the block.
9202 PUSH_SEND_WITH_BLOCK(ret, location, idEach, INT2FIX(0), child_iseq);
9203 pm_compile_retry_end_label(iseq, ret, retry_end_l);
9204
9205 if (popped) PUSH_INSN(ret, location, pop);
9206 ISEQ_COMPILE_DATA(iseq)->current_block = prev_block;
9207 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, child_iseq, retry_end_l);
9208 return;
9209 }
9210 case PM_FORWARDING_ARGUMENTS_NODE:
9211 rb_bug("Cannot compile a ForwardingArgumentsNode directly\n");
9212 return;
9213 case PM_FORWARDING_SUPER_NODE:
9214 // super
9215 // ^^^^^
9216 //
9217 // super {}
9218 // ^^^^^^^^
9219 pm_compile_forwarding_super_node(iseq, (const pm_forwarding_super_node_t *) node, &location, ret, popped, scope_node);
9220 return;
9221 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
9222 // $foo &&= bar
9223 // ^^^^^^^^^^^^
9224 const pm_global_variable_and_write_node_t *cast = (const pm_global_variable_and_write_node_t *) node;
9225 LABEL *end_label = NEW_LABEL(location.line);
9226
9227 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9228 PUSH_INSN1(ret, location, getglobal, name);
9229 if (!popped) PUSH_INSN(ret, location, dup);
9230
9231 PUSH_INSNL(ret, location, branchunless, end_label);
9232 if (!popped) PUSH_INSN(ret, location, pop);
9233
9234 PM_COMPILE_NOT_POPPED(cast->value);
9235 if (!popped) PUSH_INSN(ret, location, dup);
9236
9237 PUSH_INSN1(ret, location, setglobal, name);
9238 PUSH_LABEL(ret, end_label);
9239
9240 return;
9241 }
9242 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
9243 // $foo += bar
9244 // ^^^^^^^^^^^
9245 const pm_global_variable_operator_write_node_t *cast = (const pm_global_variable_operator_write_node_t *) node;
9246
9247 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9248 PUSH_INSN1(ret, location, getglobal, name);
9249 PM_COMPILE_NOT_POPPED(cast->value);
9250
9251 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9252 int flags = VM_CALL_ARGS_SIMPLE;
9253 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
9254
9255 if (!popped) PUSH_INSN(ret, location, dup);
9256 PUSH_INSN1(ret, location, setglobal, name);
9257
9258 return;
9259 }
9260 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
9261 // $foo ||= bar
9262 // ^^^^^^^^^^^^
9263 const pm_global_variable_or_write_node_t *cast = (const pm_global_variable_or_write_node_t *) node;
9264 LABEL *set_label = NEW_LABEL(location.line);
9265 LABEL *end_label = NEW_LABEL(location.line);
9266
9267 PUSH_INSN(ret, location, putnil);
9268 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9269
9270 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_GVAR), name, Qtrue);
9271 PUSH_INSNL(ret, location, branchunless, set_label);
9272
9273 PUSH_INSN1(ret, location, getglobal, name);
9274 if (!popped) PUSH_INSN(ret, location, dup);
9275
9276 PUSH_INSNL(ret, location, branchif, end_label);
9277 if (!popped) PUSH_INSN(ret, location, pop);
9278
9279 PUSH_LABEL(ret, set_label);
9280 PM_COMPILE_NOT_POPPED(cast->value);
9281 if (!popped) PUSH_INSN(ret, location, dup);
9282
9283 PUSH_INSN1(ret, location, setglobal, name);
9284 PUSH_LABEL(ret, end_label);
9285
9286 return;
9287 }
9288 case PM_GLOBAL_VARIABLE_READ_NODE: {
9289 // $foo
9290 // ^^^^
9291 const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
9292 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9293
9294 PUSH_INSN1(ret, location, getglobal, name);
9295 if (popped) PUSH_INSN(ret, location, pop);
9296
9297 return;
9298 }
9299 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
9300 // $foo = 1
9301 // ^^^^^^^^
9302 const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
9303 PM_COMPILE_NOT_POPPED(cast->value);
9304 if (!popped) PUSH_INSN(ret, location, dup);
9305
9306 ID name = pm_constant_id_lookup(scope_node, cast->name);
9307 PUSH_INSN1(ret, location, setglobal, ID2SYM(name));
9308
9309 return;
9310 }
9311 case PM_HASH_NODE: {
9312 // {}
9313 // ^^
9314 //
9315 // If every node in the hash is static, then we can compile the entire
9316 // hash now instead of later.
9317 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9318 // We're only going to compile this node if it's not popped. If it
9319 // is popped, then we know we don't need to do anything since it's
9320 // statically known.
9321 if (!popped) {
9322 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
9323
9324 if (cast->elements.size == 0) {
9325 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
9326 }
9327 else {
9328 VALUE value = pm_static_literal_value(iseq, node, scope_node);
9329 PUSH_INSN1(ret, location, duphash, value);
9330 RB_OBJ_WRITTEN(iseq, Qundef, value);
9331 }
9332 }
9333 }
9334 else {
9335 // Here since we know there are possible side-effects inside the
9336 // hash contents, we're going to build it entirely at runtime. We'll
9337 // do this by pushing all of the key-value pairs onto the stack and
9338 // then combining them with newhash.
9339 //
9340 // If this hash is popped, then this serves only to ensure we enact
9341 // all side-effects (like method calls) that are contained within
9342 // the hash contents.
9343 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
9344 const pm_node_list_t *elements = &cast->elements;
9345
9346 if (popped) {
9347 // If this hash is popped, then we can iterate through each
9348 // element and compile it. The result of each compilation will
9349 // only include the side effects of the element itself.
9350 for (size_t index = 0; index < elements->size; index++) {
9351 PM_COMPILE_POPPED(elements->nodes[index]);
9352 }
9353 }
9354 else {
9355 pm_compile_hash_elements(iseq, node, elements, 0, Qundef, false, ret, scope_node);
9356 }
9357 }
9358
9359 return;
9360 }
9361 case PM_IF_NODE: {
9362 // if foo then bar end
9363 // ^^^^^^^^^^^^^^^^^^^
9364 //
9365 // bar if foo
9366 // ^^^^^^^^^^
9367 //
9368 // foo ? bar : baz
9369 // ^^^^^^^^^^^^^^^
9370 const pm_if_node_t *cast = (const pm_if_node_t *) node;
9371 pm_compile_conditional(iseq, &location, PM_IF_NODE, (const pm_node_t *) cast, cast->statements, cast->subsequent, cast->predicate, ret, popped, scope_node);
9372 return;
9373 }
9374 case PM_IMAGINARY_NODE: {
9375 // 1i
9376 // ^^
9377 if (!popped) {
9378 VALUE operand = parse_imaginary((const pm_imaginary_node_t *) node);
9379 PUSH_INSN1(ret, location, putobject, operand);
9380 }
9381 return;
9382 }
9383 case PM_IMPLICIT_NODE: {
9384 // Implicit nodes mark places in the syntax tree where explicit syntax
9385 // was omitted, but implied. For example,
9386 //
9387 // { foo: }
9388 //
9389 // In this case a method call/local variable read is implied by virtue
9390 // of the missing value. To compile these nodes, we simply compile the
9391 // value that is implied, which is helpfully supplied by the parser.
9392 const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
9393 PM_COMPILE(cast->value);
9394 return;
9395 }
9396 case PM_IN_NODE: {
9397 // In nodes are handled by the case match node directly, so we should
9398 // never end up hitting them through this path.
9399 rb_bug("Should not ever enter an in node directly");
9400 return;
9401 }
9402 case PM_INDEX_OPERATOR_WRITE_NODE: {
9403 // foo[bar] += baz
9404 // ^^^^^^^^^^^^^^^
9405 const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
9406 pm_compile_index_operator_write_node(iseq, cast, &location, ret, popped, scope_node);
9407 return;
9408 }
9409 case PM_INDEX_AND_WRITE_NODE: {
9410 // foo[bar] &&= baz
9411 // ^^^^^^^^^^^^^^^^
9412 const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
9413 pm_compile_index_control_flow_write_node(iseq, node, cast->receiver, cast->arguments, cast->block, cast->value, &location, ret, popped, scope_node);
9414 return;
9415 }
9416 case PM_INDEX_OR_WRITE_NODE: {
9417 // foo[bar] ||= baz
9418 // ^^^^^^^^^^^^^^^^
9419 const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
9420 pm_compile_index_control_flow_write_node(iseq, node, cast->receiver, cast->arguments, cast->block, cast->value, &location, ret, popped, scope_node);
9421 return;
9422 }
9423 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
9424 // @foo &&= bar
9425 // ^^^^^^^^^^^^
9426 const pm_instance_variable_and_write_node_t *cast = (const pm_instance_variable_and_write_node_t *) node;
9427 LABEL *end_label = NEW_LABEL(location.line);
9428
9429 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9430 VALUE name = ID2SYM(name_id);
9431
9432 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9433 if (!popped) PUSH_INSN(ret, location, dup);
9434
9435 PUSH_INSNL(ret, location, branchunless, end_label);
9436 if (!popped) PUSH_INSN(ret, location, pop);
9437
9438 PM_COMPILE_NOT_POPPED(cast->value);
9439 if (!popped) PUSH_INSN(ret, location, dup);
9440
9441 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9442 PUSH_LABEL(ret, end_label);
9443
9444 return;
9445 }
9446 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
9447 // @foo += bar
9448 // ^^^^^^^^^^^
9449 const pm_instance_variable_operator_write_node_t *cast = (const pm_instance_variable_operator_write_node_t *) node;
9450
9451 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9452 VALUE name = ID2SYM(name_id);
9453
9454 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9455 PM_COMPILE_NOT_POPPED(cast->value);
9456
9457 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9458 int flags = VM_CALL_ARGS_SIMPLE;
9459 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
9460
9461 if (!popped) PUSH_INSN(ret, location, dup);
9462 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9463
9464 return;
9465 }
9466 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
9467 // @foo ||= bar
9468 // ^^^^^^^^^^^^
9469 const pm_instance_variable_or_write_node_t *cast = (const pm_instance_variable_or_write_node_t *) node;
9470 LABEL *end_label = NEW_LABEL(location.line);
9471
9472 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9473 VALUE name = ID2SYM(name_id);
9474
9475 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9476 if (!popped) PUSH_INSN(ret, location, dup);
9477
9478 PUSH_INSNL(ret, location, branchif, end_label);
9479 if (!popped) PUSH_INSN(ret, location, pop);
9480
9481 PM_COMPILE_NOT_POPPED(cast->value);
9482 if (!popped) PUSH_INSN(ret, location, dup);
9483
9484 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9485 PUSH_LABEL(ret, end_label);
9486
9487 return;
9488 }
9489 case PM_INSTANCE_VARIABLE_READ_NODE: {
9490 // @foo
9491 // ^^^^
9492 if (!popped) {
9493 const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
9494 ID name = pm_constant_id_lookup(scope_node, cast->name);
9495 PUSH_INSN2(ret, location, getinstancevariable, ID2SYM(name), get_ivar_ic_value(iseq, name));
9496 }
9497 return;
9498 }
9499 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
9500 // @foo = 1
9501 // ^^^^^^^^
9502 const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
9503 PM_COMPILE_NOT_POPPED(cast->value);
9504 if (!popped) PUSH_INSN(ret, location, dup);
9505
9506 ID name = pm_constant_id_lookup(scope_node, cast->name);
9507 PUSH_INSN2(ret, location, setinstancevariable, ID2SYM(name), get_ivar_ic_value(iseq, name));
9508
9509 return;
9510 }
9511 case PM_INTEGER_NODE: {
9512 // 1
9513 // ^
9514 if (!popped) {
9515 VALUE operand = parse_integer((const pm_integer_node_t *) node);
9516 PUSH_INSN1(ret, location, putobject, operand);
9517 }
9518 return;
9519 }
9520 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
9521 // if /foo #{bar}/ then end
9522 // ^^^^^^^^^^^^
9523 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9524 if (!popped) {
9525 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9526 PUSH_INSN1(ret, location, putobject, regexp);
9527 }
9528 }
9529 else {
9530 pm_compile_regexp_dynamic(iseq, node, &((const pm_interpolated_match_last_line_node_t *) node)->parts, &location, ret, popped, scope_node);
9531 }
9532
9533 PUSH_INSN1(ret, location, getglobal, rb_id2sym(idLASTLINE));
9534 PUSH_SEND(ret, location, idEqTilde, INT2NUM(1));
9535 if (popped) PUSH_INSN(ret, location, pop);
9536
9537 return;
9538 }
9539 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
9540 // /foo #{bar}/
9541 // ^^^^^^^^^^^^
9542 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
9543 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
9544 const rb_iseq_t *block_iseq = NULL;
9545 int ise_index = ISEQ_BODY(iseq)->ise_size++;
9546
9547 pm_scope_node_t next_scope_node;
9548 pm_scope_node_init(node, &next_scope_node, scope_node);
9549
9550 block_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_PLAIN, location.line);
9551 pm_scope_node_destroy(&next_scope_node);
9552
9553 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
9554 PUSH_INSN2(ret, location, once, block_iseq, INT2FIX(ise_index));
9555 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
9556
9557 if (popped) PUSH_INSN(ret, location, pop);
9558 return;
9559 }
9560
9561 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9562 if (!popped) {
9563 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9564 PUSH_INSN1(ret, location, putobject, regexp);
9565 }
9566 }
9567 else {
9568 pm_compile_regexp_dynamic(iseq, node, &((const pm_interpolated_regular_expression_node_t *) node)->parts, &location, ret, popped, scope_node);
9569 if (popped) PUSH_INSN(ret, location, pop);
9570 }
9571
9572 return;
9573 }
9574 case PM_INTERPOLATED_STRING_NODE: {
9575 // "foo #{bar}"
9576 // ^^^^^^^^^^^^
9577 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9578 if (!popped) {
9579 VALUE string = pm_static_literal_value(iseq, node, scope_node);
9580
9581 if (PM_NODE_FLAG_P(node, PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN)) {
9582 PUSH_INSN1(ret, location, putobject, string);
9583 }
9584 else if (PM_NODE_FLAG_P(node, PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE)) {
9585 PUSH_INSN1(ret, location, putstring, string);
9586 }
9587 else {
9588 PUSH_INSN1(ret, location, putchilledstring, string);
9589 }
9590 }
9591 }
9592 else {
9593 const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
9594 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, popped, scope_node, NULL, NULL, PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE), PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN));
9595 if (length > 1) PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9596 if (popped) PUSH_INSN(ret, location, pop);
9597 }
9598
9599 return;
9600 }
9601 case PM_INTERPOLATED_SYMBOL_NODE: {
9602 // :"foo #{bar}"
9603 // ^^^^^^^^^^^^^
9604 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
9605 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, popped, scope_node, NULL, NULL, false, false);
9606
9607 if (length > 1) {
9608 PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9609 }
9610
9611 if (!popped) {
9612 PUSH_INSN(ret, location, intern);
9613 }
9614 else {
9615 PUSH_INSN(ret, location, pop);
9616 }
9617
9618 return;
9619 }
9620 case PM_INTERPOLATED_X_STRING_NODE: {
9621 // `foo #{bar}`
9622 // ^^^^^^^^^^^^
9623 const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
9624
9625 PUSH_INSN(ret, location, putself);
9626
9627 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, false, scope_node, NULL, NULL, false, false);
9628 if (length > 1) PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9629
9630 PUSH_SEND_WITH_FLAG(ret, location, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
9631 if (popped) PUSH_INSN(ret, location, pop);
9632
9633 return;
9634 }
9635 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
9636 // -> { it }
9637 // ^^
9638 if (!popped) {
9639 pm_scope_node_t *current_scope_node = scope_node;
9640 int level = 0;
9641
9642 while (current_scope_node) {
9643 if (current_scope_node->parameters && PM_NODE_TYPE_P(current_scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
9644 PUSH_GETLOCAL(ret, location, current_scope_node->local_table_for_iseq_size, level);
9645 return;
9646 }
9647
9648 current_scope_node = current_scope_node->previous;
9649 level++;
9650 }
9651 rb_bug("Local `it` does not exist");
9652 }
9653
9654 return;
9655 }
9656 case PM_KEYWORD_HASH_NODE: {
9657 // foo(bar: baz)
9658 // ^^^^^^^^
9659 const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
9660 const pm_node_list_t *elements = &cast->elements;
9661
9662 const pm_node_t *element;
9663 PM_NODE_LIST_FOREACH(elements, index, element) {
9664 PM_COMPILE(element);
9665 }
9666
9667 if (!popped) PUSH_INSN1(ret, location, newhash, INT2FIX(elements->size * 2));
9668 return;
9669 }
9670 case PM_LAMBDA_NODE: {
9671 // -> {}
9672 // ^^^^^
9673 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
9674
9675 pm_scope_node_t next_scope_node;
9676 pm_scope_node_init(node, &next_scope_node, scope_node);
9677
9678 int opening_lineno = pm_location_line_number(parser, &cast->opening_loc);
9679 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, opening_lineno);
9680 pm_scope_node_destroy(&next_scope_node);
9681
9682 VALUE argc = INT2FIX(0);
9683 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
9684 PUSH_CALL_WITH_BLOCK(ret, location, idLambda, argc, block);
9685 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) block);
9686
9687 if (popped) PUSH_INSN(ret, location, pop);
9688 return;
9689 }
9690 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
9691 // foo &&= bar
9692 // ^^^^^^^^^^^
9693 const pm_local_variable_and_write_node_t *cast = (const pm_local_variable_and_write_node_t *) node;
9694 LABEL *end_label = NEW_LABEL(location.line);
9695
9696 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9697 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9698 if (!popped) PUSH_INSN(ret, location, dup);
9699
9700 PUSH_INSNL(ret, location, branchunless, end_label);
9701 if (!popped) PUSH_INSN(ret, location, pop);
9702
9703 PM_COMPILE_NOT_POPPED(cast->value);
9704 if (!popped) PUSH_INSN(ret, location, dup);
9705
9706 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9707 PUSH_LABEL(ret, end_label);
9708
9709 return;
9710 }
9711 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
9712 // foo += bar
9713 // ^^^^^^^^^^
9714 const pm_local_variable_operator_write_node_t *cast = (const pm_local_variable_operator_write_node_t *) node;
9715
9716 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9717 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9718
9719 PM_COMPILE_NOT_POPPED(cast->value);
9720
9721 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9722 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
9723
9724 if (!popped) PUSH_INSN(ret, location, dup);
9725 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9726
9727 return;
9728 }
9729 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
9730 // foo ||= bar
9731 // ^^^^^^^^^^^
9732 const pm_local_variable_or_write_node_t *cast = (const pm_local_variable_or_write_node_t *) node;
9733
9734 LABEL *set_label = NEW_LABEL(location.line);
9735 LABEL *end_label = NEW_LABEL(location.line);
9736
9737 PUSH_INSN1(ret, location, putobject, Qtrue);
9738 PUSH_INSNL(ret, location, branchunless, set_label);
9739
9740 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9741 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9742 if (!popped) PUSH_INSN(ret, location, dup);
9743
9744 PUSH_INSNL(ret, location, branchif, end_label);
9745 if (!popped) PUSH_INSN(ret, location, pop);
9746
9747 PUSH_LABEL(ret, set_label);
9748 PM_COMPILE_NOT_POPPED(cast->value);
9749 if (!popped) PUSH_INSN(ret, location, dup);
9750
9751 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9752 PUSH_LABEL(ret, end_label);
9753
9754 return;
9755 }
9756 case PM_LOCAL_VARIABLE_READ_NODE: {
9757 // foo
9758 // ^^^
9759 if (!popped) {
9760 const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) node;
9761 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9762 PUSH_GETLOCAL(ret, location, index.index, index.level);
9763 }
9764
9765 return;
9766 }
9767 case PM_LOCAL_VARIABLE_WRITE_NODE: {
9768 // foo = 1
9769 // ^^^^^^^
9770 const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
9771 PM_COMPILE_NOT_POPPED(cast->value);
9772 if (!popped) PUSH_INSN(ret, location, dup);
9773
9774 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9775 PUSH_SETLOCAL(ret, location, index.index, index.level);
9776 return;
9777 }
9778 case PM_MATCH_LAST_LINE_NODE: {
9779 // if /foo/ then end
9780 // ^^^^^
9781 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9782
9783 PUSH_INSN1(ret, location, putobject, regexp);
9784 PUSH_INSN2(ret, location, getspecial, INT2FIX(0), INT2FIX(0));
9785 PUSH_SEND(ret, location, idEqTilde, INT2NUM(1));
9786 if (popped) PUSH_INSN(ret, location, pop);
9787
9788 return;
9789 }
9790 case PM_MATCH_PREDICATE_NODE: {
9791 // foo in bar
9792 // ^^^^^^^^^^
9793 const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
9794
9795 // First, allocate some stack space for the cached return value of any
9796 // calls to #deconstruct.
9797 PUSH_INSN(ret, location, putnil);
9798
9799 // Next, compile the expression that we're going to match against.
9800 PM_COMPILE_NOT_POPPED(cast->value);
9801 PUSH_INSN(ret, location, dup);
9802
9803 // Now compile the pattern that is going to be used to match against the
9804 // expression.
9805 LABEL *matched_label = NEW_LABEL(location.line);
9806 LABEL *unmatched_label = NEW_LABEL(location.line);
9807 LABEL *done_label = NEW_LABEL(location.line);
9808 pm_compile_pattern(iseq, scope_node, cast->pattern, ret, matched_label, unmatched_label, false, true, 2);
9809
9810 // If the pattern did not match, then compile the necessary instructions
9811 // to handle pushing false onto the stack, then jump to the end.
9812 PUSH_LABEL(ret, unmatched_label);
9813 PUSH_INSN(ret, location, pop);
9814 PUSH_INSN(ret, location, pop);
9815
9816 if (!popped) PUSH_INSN1(ret, location, putobject, Qfalse);
9817 PUSH_INSNL(ret, location, jump, done_label);
9818 PUSH_INSN(ret, location, putnil);
9819
9820 // If the pattern did match, then compile the necessary instructions to
9821 // handle pushing true onto the stack, then jump to the end.
9822 PUSH_LABEL(ret, matched_label);
9823 PUSH_INSN1(ret, location, adjuststack, INT2FIX(2));
9824 if (!popped) PUSH_INSN1(ret, location, putobject, Qtrue);
9825 PUSH_INSNL(ret, location, jump, done_label);
9826
9827 PUSH_LABEL(ret, done_label);
9828 return;
9829 }
9830 case PM_MATCH_REQUIRED_NODE:
9831 // foo => bar
9832 // ^^^^^^^^^^
9833 //
9834 // A match required node represents pattern matching against a single
9835 // pattern using the => operator. For example,
9836 //
9837 // foo => bar
9838 //
9839 // This is somewhat analogous to compiling a case match statement with a
9840 // single pattern. In both cases, if the pattern fails it should
9841 // immediately raise an error.
9842 pm_compile_match_required_node(iseq, (const pm_match_required_node_t *) node, &location, ret, popped, scope_node);
9843 return;
9844 case PM_MATCH_WRITE_NODE:
9845 // /(?<foo>foo)/ =~ bar
9846 // ^^^^^^^^^^^^^^^^^^^^
9847 //
9848 // Match write nodes are specialized call nodes that have a regular
9849 // expression with valid named capture groups on the left, the =~
9850 // operator, and some value on the right. The nodes themselves simply
9851 // wrap the call with the local variable targets that will be written
9852 // when the call is executed.
9853 pm_compile_match_write_node(iseq, (const pm_match_write_node_t *) node, &location, ret, popped, scope_node);
9854 return;
9855 case PM_MISSING_NODE:
9856 rb_bug("A pm_missing_node_t should not exist in prism's AST.");
9857 return;
9858 case PM_MODULE_NODE: {
9859 // module Foo; end
9860 // ^^^^^^^^^^^^^^^
9861 const pm_module_node_t *cast = (const pm_module_node_t *) node;
9862
9863 ID module_id = pm_constant_id_lookup(scope_node, cast->name);
9864 VALUE module_name = rb_str_freeze(rb_sprintf("<module:%"PRIsVALUE">", rb_id2str(module_id)));
9865
9866 pm_scope_node_t next_scope_node;
9867 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9868
9869 const rb_iseq_t *module_iseq = NEW_CHILD_ISEQ(&next_scope_node, module_name, ISEQ_TYPE_CLASS, location.line);
9870 pm_scope_node_destroy(&next_scope_node);
9871
9872 const int flags = VM_DEFINECLASS_TYPE_MODULE | pm_compile_class_path(iseq, cast->constant_path, &location, ret, false, scope_node);
9873 PUSH_INSN(ret, location, putnil);
9874 PUSH_INSN3(ret, location, defineclass, ID2SYM(module_id), module_iseq, INT2FIX(flags));
9875 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) module_iseq);
9876
9877 if (popped) PUSH_INSN(ret, location, pop);
9878 return;
9879 }
9880 case PM_REQUIRED_PARAMETER_NODE: {
9881 // def foo(bar); end
9882 // ^^^
9883 const pm_required_parameter_node_t *cast = (const pm_required_parameter_node_t *) node;
9884 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, 0);
9885
9886 PUSH_SETLOCAL(ret, location, index.index, index.level);
9887 return;
9888 }
9889 case PM_MULTI_WRITE_NODE: {
9890 // foo, bar = baz
9891 // ^^^^^^^^^^^^^^
9892 //
9893 // A multi write node represents writing to multiple values using an =
9894 // operator. Importantly these nodes are only parsed when the left-hand
9895 // side of the operator has multiple targets. The right-hand side of the
9896 // operator having multiple targets represents an implicit array
9897 // instead.
9898 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
9899
9900 DECL_ANCHOR(writes);
9901 DECL_ANCHOR(cleanup);
9902
9903 pm_multi_target_state_t state = { 0 };
9904 state.position = popped ? 0 : 1;
9905 pm_compile_multi_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
9906
9907 PM_COMPILE_NOT_POPPED(cast->value);
9908 if (!popped) PUSH_INSN(ret, location, dup);
9909
9910 PUSH_SEQ(ret, writes);
9911 if (!popped && state.stack_size >= 1) {
9912 // Make sure the value on the right-hand side of the = operator is
9913 // being returned before we pop the parent expressions.
9914 PUSH_INSN1(ret, location, setn, INT2FIX(state.stack_size));
9915 }
9916
9917 // Now, we need to go back and modify the topn instructions in order to
9918 // ensure they can correctly retrieve the parent expressions.
9919 pm_multi_target_state_update(&state);
9920
9921 PUSH_SEQ(ret, cleanup);
9922 return;
9923 }
9924 case PM_NEXT_NODE:
9925 // next
9926 // ^^^^
9927 //
9928 // next foo
9929 // ^^^^^^^^
9930 pm_compile_next_node(iseq, (const pm_next_node_t *) node, &location, ret, popped, scope_node);
9931 return;
9932 case PM_NIL_NODE: {
9933 // nil
9934 // ^^^
9935 if (!popped) {
9936 PUSH_INSN(ret, location, putnil);
9937 }
9938
9939 return;
9940 }
9941 case PM_NO_KEYWORDS_PARAMETER_NODE: {
9942 // def foo(**nil); end
9943 // ^^^^^
9944 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg = TRUE;
9945 return;
9946 }
9947 case PM_NUMBERED_REFERENCE_READ_NODE: {
9948 // $1
9949 // ^^
9950 if (!popped) {
9951 const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
9952
9953 if (cast->number != 0) {
9954 VALUE ref = pm_compile_numbered_reference_ref(cast);
9955 PUSH_INSN2(ret, location, getspecial, INT2FIX(1), ref);
9956 }
9957 else {
9958 PUSH_INSN(ret, location, putnil);
9959 }
9960 }
9961
9962 return;
9963 }
9964 case PM_OR_NODE: {
9965 // a or b
9966 // ^^^^^^
9967 const pm_or_node_t *cast = (const pm_or_node_t *) node;
9968
9969 LABEL *end_label = NEW_LABEL(location.line);
9970 PM_COMPILE_NOT_POPPED(cast->left);
9971
9972 if (!popped) PUSH_INSN(ret, location, dup);
9973 PUSH_INSNL(ret, location, branchif, end_label);
9974
9975 if (!popped) PUSH_INSN(ret, location, pop);
9976 PM_COMPILE(cast->right);
9977 PUSH_LABEL(ret, end_label);
9978
9979 return;
9980 }
9981 case PM_OPTIONAL_PARAMETER_NODE: {
9982 // def foo(bar = 1); end
9983 // ^^^^^^^
9984 const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
9985 PM_COMPILE_NOT_POPPED(cast->value);
9986
9987 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, 0);
9988 PUSH_SETLOCAL(ret, location, index.index, index.level);
9989
9990 return;
9991 }
9992 case PM_PARENTHESES_NODE: {
9993 // ()
9994 // ^^
9995 //
9996 // (1)
9997 // ^^^
9998 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
9999
10000 if (cast->body != NULL) {
10001 PM_COMPILE(cast->body);
10002 }
10003 else if (!popped) {
10004 PUSH_INSN(ret, location, putnil);
10005 }
10006
10007 return;
10008 }
10009 case PM_PRE_EXECUTION_NODE: {
10010 // BEGIN {}
10011 // ^^^^^^^^
10012 const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
10013
10014 LINK_ANCHOR *outer_pre = scope_node->pre_execution_anchor;
10015 RUBY_ASSERT(outer_pre != NULL);
10016
10017 // BEGIN{} nodes can be nested, so here we're going to do the same thing
10018 // that we did for the top-level compilation where we create two
10019 // anchors and then join them in the correct order into the resulting
10020 // anchor.
10021 DECL_ANCHOR(inner_pre);
10022 scope_node->pre_execution_anchor = inner_pre;
10023
10024 DECL_ANCHOR(inner_body);
10025
10026 if (cast->statements != NULL) {
10027 const pm_node_list_t *body = &cast->statements->body;
10028
10029 for (size_t index = 0; index < body->size; index++) {
10030 pm_compile_node(iseq, body->nodes[index], inner_body, true, scope_node);
10031 }
10032 }
10033
10034 if (!popped) {
10035 PUSH_INSN(inner_body, location, putnil);
10036 }
10037
10038 // Now that everything has been compiled, join both anchors together
10039 // into the correct outer pre execution anchor, and reset the value so
10040 // that subsequent BEGIN{} nodes can be compiled correctly.
10041 PUSH_SEQ(outer_pre, inner_pre);
10042 PUSH_SEQ(outer_pre, inner_body);
10043 scope_node->pre_execution_anchor = outer_pre;
10044
10045 return;
10046 }
10047 case PM_POST_EXECUTION_NODE: {
10048 // END {}
10049 // ^^^^^^
10050 const rb_iseq_t *child_iseq;
10051 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
10052
10053 pm_scope_node_t next_scope_node;
10054 pm_scope_node_init(node, &next_scope_node, scope_node);
10055 child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno);
10056 pm_scope_node_destroy(&next_scope_node);
10057
10058 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
10059
10060 int is_index = ISEQ_BODY(iseq)->ise_size++;
10061 PUSH_INSN2(ret, location, once, child_iseq, INT2FIX(is_index));
10062 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) child_iseq);
10063 if (popped) PUSH_INSN(ret, location, pop);
10064
10065 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
10066
10067 return;
10068 }
10069 case PM_RANGE_NODE: {
10070 // 0..5
10071 // ^^^^
10072 const pm_range_node_t *cast = (const pm_range_node_t *) node;
10073 bool exclude_end = PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END);
10074
10075 if (pm_optimizable_range_item_p(cast->left) && pm_optimizable_range_item_p(cast->right)) {
10076 if (!popped) {
10077 const pm_node_t *left = cast->left;
10078 const pm_node_t *right = cast->right;
10079
10080 VALUE val = rb_range_new(
10081 (left && PM_NODE_TYPE_P(left, PM_INTEGER_NODE)) ? parse_integer((const pm_integer_node_t *) left) : Qnil,
10082 (right && PM_NODE_TYPE_P(right, PM_INTEGER_NODE)) ? parse_integer((const pm_integer_node_t *) right) : Qnil,
10083 exclude_end
10084 );
10085
10086 RB_OBJ_SET_SHAREABLE(val);
10087 PUSH_INSN1(ret, location, putobject, val);
10088 }
10089 }
10090 else {
10091 if (cast->left != NULL) {
10092 PM_COMPILE(cast->left);
10093 }
10094 else if (!popped) {
10095 PUSH_INSN(ret, location, putnil);
10096 }
10097
10098 if (cast->right != NULL) {
10099 PM_COMPILE(cast->right);
10100 }
10101 else if (!popped) {
10102 PUSH_INSN(ret, location, putnil);
10103 }
10104
10105 if (!popped) {
10106 PUSH_INSN1(ret, location, newrange, INT2FIX(exclude_end ? 1 : 0));
10107 }
10108 }
10109 return;
10110 }
10111 case PM_RATIONAL_NODE: {
10112 // 1r
10113 // ^^
10114 if (!popped) {
10115 PUSH_INSN1(ret, location, putobject, parse_rational((const pm_rational_node_t *) node));
10116 }
10117 return;
10118 }
10119 case PM_REDO_NODE:
10120 // redo
10121 // ^^^^
10122 pm_compile_redo_node(iseq, &location, ret, popped, scope_node);
10123 return;
10124 case PM_REGULAR_EXPRESSION_NODE: {
10125 // /foo/
10126 // ^^^^^
10127 if (!popped) {
10128 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
10129 PUSH_INSN1(ret, location, putobject, regexp);
10130 }
10131 return;
10132 }
10133 case PM_RESCUE_NODE:
10134 // begin; rescue; end
10135 // ^^^^^^^
10136 pm_compile_rescue_node(iseq, (const pm_rescue_node_t *) node, &location, ret, popped, scope_node);
10137 return;
10138 case PM_RESCUE_MODIFIER_NODE: {
10139 // foo rescue bar
10140 // ^^^^^^^^^^^^^^
10141 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
10142
10143 pm_scope_node_t rescue_scope_node;
10144 pm_scope_node_init((const pm_node_t *) cast, &rescue_scope_node, scope_node);
10145
10146 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
10147 &rescue_scope_node,
10148 rb_str_concat(rb_str_new2("rescue in "), ISEQ_BODY(iseq)->location.label),
10149 ISEQ_TYPE_RESCUE,
10150 pm_node_line_number(parser, cast->rescue_expression)
10151 );
10152
10153 pm_scope_node_destroy(&rescue_scope_node);
10154
10155 LABEL *lstart = NEW_LABEL(location.line);
10156 LABEL *lend = NEW_LABEL(location.line);
10157 LABEL *lcont = NEW_LABEL(location.line);
10158
10159 lstart->rescued = LABEL_RESCUE_BEG;
10160 lend->rescued = LABEL_RESCUE_END;
10161
10162 PUSH_LABEL(ret, lstart);
10163 PM_COMPILE_NOT_POPPED(cast->expression);
10164 PUSH_LABEL(ret, lend);
10165
10166 PUSH_INSN(ret, location, nop);
10167 PUSH_LABEL(ret, lcont);
10168 if (popped) PUSH_INSN(ret, location, pop);
10169
10170 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
10171 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
10172 return;
10173 }
10174 case PM_RETURN_NODE:
10175 // return
10176 // ^^^^^^
10177 //
10178 // return 1
10179 // ^^^^^^^^
10180 pm_compile_return_node(iseq, (const pm_return_node_t *) node, &location, ret, popped, scope_node);
10181 return;
10182 case PM_RETRY_NODE: {
10183 // retry
10184 // ^^^^^
10185 if (ISEQ_BODY(iseq)->type == ISEQ_TYPE_RESCUE) {
10186 PUSH_INSN(ret, location, putnil);
10187 PUSH_INSN1(ret, location, throw, INT2FIX(TAG_RETRY));
10188 if (popped) PUSH_INSN(ret, location, pop);
10189 }
10190 else {
10191 COMPILE_ERROR(iseq, location.line, "Invalid retry");
10192 return;
10193 }
10194 return;
10195 }
10196 case PM_SCOPE_NODE:
10197 pm_compile_scope_node(iseq, (pm_scope_node_t *) node, &location, ret, popped);
10198 return;
10199 case PM_SELF_NODE: {
10200 // self
10201 // ^^^^
10202 if (!popped) {
10203 PUSH_INSN(ret, location, putself);
10204 }
10205 return;
10206 }
10207 case PM_SHAREABLE_CONSTANT_NODE: {
10208 // A value that is being written to a constant that is being marked as
10209 // shared depending on the current lexical context.
10210 const pm_shareable_constant_node_t *cast = (const pm_shareable_constant_node_t *) node;
10211 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));
10212
10213 switch (PM_NODE_TYPE(cast->write)) {
10214 case PM_CONSTANT_WRITE_NODE:
10215 pm_compile_constant_write_node(iseq, (const pm_constant_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10216 break;
10217 case PM_CONSTANT_AND_WRITE_NODE:
10218 pm_compile_constant_and_write_node(iseq, (const pm_constant_and_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10219 break;
10220 case PM_CONSTANT_OR_WRITE_NODE:
10221 pm_compile_constant_or_write_node(iseq, (const pm_constant_or_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10222 break;
10223 case PM_CONSTANT_OPERATOR_WRITE_NODE:
10224 pm_compile_constant_operator_write_node(iseq, (const pm_constant_operator_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10225 break;
10226 case PM_CONSTANT_PATH_WRITE_NODE:
10227 pm_compile_constant_path_write_node(iseq, (const pm_constant_path_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10228 break;
10229 case PM_CONSTANT_PATH_AND_WRITE_NODE:
10230 pm_compile_constant_path_and_write_node(iseq, (const pm_constant_path_and_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10231 break;
10232 case PM_CONSTANT_PATH_OR_WRITE_NODE:
10233 pm_compile_constant_path_or_write_node(iseq, (const pm_constant_path_or_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10234 break;
10235 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE:
10236 pm_compile_constant_path_operator_write_node(iseq, (const pm_constant_path_operator_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10237 break;
10238 default:
10239 rb_bug("Unexpected node type for shareable constant write: %s", pm_node_type_to_str(PM_NODE_TYPE(cast->write)));
10240 break;
10241 }
10242
10243 return;
10244 }
10245 case PM_SINGLETON_CLASS_NODE: {
10246 // class << self; end
10247 // ^^^^^^^^^^^^^^^^^^
10248 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
10249
10250 pm_scope_node_t next_scope_node;
10251 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
10252 const rb_iseq_t *child_iseq = NEW_ISEQ(&next_scope_node, rb_fstring_lit("singleton class"), ISEQ_TYPE_CLASS, location.line);
10253 pm_scope_node_destroy(&next_scope_node);
10254
10255 PM_COMPILE_NOT_POPPED(cast->expression);
10256 PUSH_INSN(ret, location, putnil);
10257
10258 ID singletonclass;
10259 CONST_ID(singletonclass, "singletonclass");
10260 PUSH_INSN3(ret, location, defineclass, ID2SYM(singletonclass), child_iseq, INT2FIX(VM_DEFINECLASS_TYPE_SINGLETON_CLASS));
10261
10262 if (popped) PUSH_INSN(ret, location, pop);
10263 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) child_iseq);
10264
10265 return;
10266 }
10267 case PM_SOURCE_ENCODING_NODE: {
10268 // __ENCODING__
10269 // ^^^^^^^^^^^^
10270 if (!popped) {
10271 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10272 PUSH_INSN1(ret, location, putobject, value);
10273 }
10274 return;
10275 }
10276 case PM_SOURCE_FILE_NODE: {
10277 // __FILE__
10278 // ^^^^^^^^
10279 if (!popped) {
10280 const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
10281 VALUE string = pm_source_file_value(cast, scope_node);
10282
10283 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
10284 PUSH_INSN1(ret, location, putobject, string);
10285 }
10286 else if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
10287 PUSH_INSN1(ret, location, putstring, string);
10288 }
10289 else {
10290 PUSH_INSN1(ret, location, putchilledstring, string);
10291 }
10292 }
10293 return;
10294 }
10295 case PM_SOURCE_LINE_NODE: {
10296 // __LINE__
10297 // ^^^^^^^^
10298 if (!popped) {
10299 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10300 PUSH_INSN1(ret, location, putobject, value);
10301 }
10302 return;
10303 }
10304 case PM_SPLAT_NODE: {
10305 // foo(*bar)
10306 // ^^^^
10307 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
10308 if (cast->expression) {
10309 PM_COMPILE(cast->expression);
10310 }
10311
10312 if (!popped) {
10313 PUSH_INSN1(ret, location, splatarray, Qtrue);
10314 }
10315 return;
10316 }
10317 case PM_STATEMENTS_NODE: {
10318 // A list of statements.
10319 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
10320 const pm_node_list_t *body = &cast->body;
10321
10322 if (body->size > 0) {
10323 for (size_t index = 0; index < body->size - 1; index++) {
10324 PM_COMPILE_POPPED(body->nodes[index]);
10325 }
10326 PM_COMPILE(body->nodes[body->size - 1]);
10327 }
10328 else {
10329 PUSH_INSN(ret, location, putnil);
10330 }
10331 return;
10332 }
10333 case PM_STRING_NODE: {
10334 // "foo"
10335 // ^^^^^
10336 if (!popped) {
10337 const pm_string_node_t *cast = (const pm_string_node_t *) node;
10338 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
10339
10340 if (PM_NODE_FLAG_P(node, PM_STRING_FLAGS_FROZEN)) {
10341 PUSH_INSN1(ret, location, putobject, value);
10342 }
10343 else if (PM_NODE_FLAG_P(node, PM_STRING_FLAGS_MUTABLE)) {
10344 PUSH_INSN1(ret, location, putstring, value);
10345 }
10346 else {
10347 PUSH_INSN1(ret, location, putchilledstring, value);
10348 }
10349 }
10350 return;
10351 }
10352 case PM_SUPER_NODE:
10353 // super()
10354 // super(foo)
10355 // super(...)
10356 pm_compile_super_node(iseq, (const pm_super_node_t *) node, &location, ret, popped, scope_node);
10357 return;
10358 case PM_SYMBOL_NODE: {
10359 // :foo
10360 // ^^^^
10361 if (!popped) {
10362 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10363 PUSH_INSN1(ret, location, putobject, value);
10364 }
10365 return;
10366 }
10367 case PM_TRUE_NODE: {
10368 // true
10369 // ^^^^
10370 if (!popped) {
10371 PUSH_INSN1(ret, location, putobject, Qtrue);
10372 }
10373 return;
10374 }
10375 case PM_UNDEF_NODE: {
10376 // undef foo
10377 // ^^^^^^^^^
10378 const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
10379 const pm_node_list_t *names = &cast->names;
10380
10381 for (size_t index = 0; index < names->size; index++) {
10382 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
10383 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
10384
10385 PM_COMPILE_NOT_POPPED(names->nodes[index]);
10386 PUSH_SEND(ret, location, id_core_undef_method, INT2NUM(2));
10387
10388 if (index < names->size - 1) {
10389 PUSH_INSN(ret, location, pop);
10390 }
10391 }
10392
10393 if (popped) PUSH_INSN(ret, location, pop);
10394 return;
10395 }
10396 case PM_UNLESS_NODE: {
10397 // unless foo; bar end
10398 // ^^^^^^^^^^^^^^^^^^^
10399 //
10400 // bar unless foo
10401 // ^^^^^^^^^^^^^^
10402 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
10403 const pm_statements_node_t *statements = NULL;
10404 if (cast->else_clause != NULL) {
10405 statements = ((const pm_else_node_t *) cast->else_clause)->statements;
10406 }
10407
10408 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);
10409 return;
10410 }
10411 case PM_UNTIL_NODE: {
10412 // until foo; bar end
10413 // ^^^^^^^^^^^^^^^^^
10414 //
10415 // bar until foo
10416 // ^^^^^^^^^^^^^
10417 const pm_until_node_t *cast = (const pm_until_node_t *) node;
10418 pm_compile_loop(iseq, &location, cast->base.flags, PM_UNTIL_NODE, (const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10419 return;
10420 }
10421 case PM_WHILE_NODE: {
10422 // while foo; bar end
10423 // ^^^^^^^^^^^^^^^^^^
10424 //
10425 // bar while foo
10426 // ^^^^^^^^^^^^^
10427 const pm_while_node_t *cast = (const pm_while_node_t *) node;
10428 pm_compile_loop(iseq, &location, cast->base.flags, PM_WHILE_NODE, (const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10429 return;
10430 }
10431 case PM_X_STRING_NODE: {
10432 // `foo`
10433 // ^^^^^
10434 const pm_x_string_node_t *cast = (const pm_x_string_node_t *) node;
10435 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
10436
10437 PUSH_INSN(ret, location, putself);
10438 PUSH_INSN1(ret, location, putobject, value);
10439 PUSH_SEND_WITH_FLAG(ret, location, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
10440 if (popped) PUSH_INSN(ret, location, pop);
10441
10442 return;
10443 }
10444 case PM_YIELD_NODE:
10445 // yield
10446 // ^^^^^
10447 //
10448 // yield 1
10449 // ^^^^^^^
10450 pm_compile_yield_node(iseq, (const pm_yield_node_t *) node, &location, ret, popped, scope_node);
10451 return;
10452 default:
10453 rb_raise(rb_eNotImpError, "node type %s not implemented", pm_node_type_to_str(PM_NODE_TYPE(node)));
10454 return;
10455 }
10456}
10457
10458#undef PM_CONTAINER_P
10459
10461static inline bool
10462pm_iseq_pre_execution_p(rb_iseq_t *iseq)
10463{
10464 switch (ISEQ_BODY(iseq)->type) {
10465 case ISEQ_TYPE_TOP:
10466 case ISEQ_TYPE_EVAL:
10467 case ISEQ_TYPE_MAIN:
10468 return true;
10469 default:
10470 return false;
10471 }
10472}
10473
10481 VALUE
10482pm_iseq_compile_node(rb_iseq_t *iseq, pm_scope_node_t *node)
10483{
10484 DECL_ANCHOR(ret);
10485
10486 if (pm_iseq_pre_execution_p(iseq)) {
10487 // Because these ISEQs can have BEGIN{}, we're going to create two
10488 // anchors to compile them, a "pre" and a "body". We'll mark the "pre"
10489 // on the scope node so that when BEGIN{} is found, its contents will be
10490 // added to the "pre" anchor.
10491 DECL_ANCHOR(pre);
10492 node->pre_execution_anchor = pre;
10493
10494 // Now we'll compile the body as normal. We won't compile directly into
10495 // the "ret" anchor yet because we want to add the "pre" anchor to the
10496 // beginning of the "ret" anchor first.
10497 DECL_ANCHOR(body);
10498 pm_compile_node(iseq, (const pm_node_t *) node, body, false, node);
10499
10500 // Now we'll join both anchors together so that the content is in the
10501 // correct order.
10502 PUSH_SEQ(ret, pre);
10503 PUSH_SEQ(ret, body);
10504 }
10505 else {
10506 // In other circumstances, we can just compile the node directly into
10507 // the "ret" anchor.
10508 pm_compile_node(iseq, (const pm_node_t *) node, ret, false, node);
10509 }
10510
10511 CHECK(iseq_setup_insn(iseq, ret));
10512 return iseq_setup(iseq, ret);
10513}
10514
10519void
10520pm_parse_result_free(pm_parse_result_t *result)
10521{
10522 if (result->node.ast_node != NULL) {
10523 pm_node_destroy(&result->parser, result->node.ast_node);
10524 }
10525
10526 if (result->parsed) {
10527 xfree(result->node.constants);
10528 pm_scope_node_destroy(&result->node);
10529 }
10530
10531 pm_parser_free(&result->parser);
10532 pm_string_free(&result->input);
10533 pm_options_free(&result->options);
10534}
10535
10537 typedef struct {
10539 pm_diagnostic_t *error;
10540
10542 int32_t line;
10543
10545 uint32_t column_start;
10546
10548 uint32_t column_end;
10549} pm_parse_error_t;
10550
10552 typedef struct {
10554 const char *number_prefix;
10555
10557 const char *blank_prefix;
10558
10560 const char *divider;
10561
10563 size_t blank_prefix_length;
10564
10566 size_t divider_length;
10567} pm_parse_error_format_t;
10568
10569#define PM_COLOR_BOLD "\033[1m"
10570#define PM_COLOR_GRAY "\033[2m"
10571#define PM_COLOR_RED "\033[1;31m"
10572#define PM_COLOR_RESET "\033[m"
10573#define PM_ERROR_TRUNCATE 30
10574
10575static inline pm_parse_error_t *
10576pm_parse_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_list, const pm_newline_list_t *newline_list) {
10577 pm_parse_error_t *errors = xcalloc(error_list->size, sizeof(pm_parse_error_t));
10578 if (errors == NULL) return NULL;
10579
10580 int32_t start_line = parser->start_line;
10581 pm_diagnostic_t *finish = (pm_diagnostic_t * )error_list->tail->next;
10582
10583 for (pm_diagnostic_t *error = (pm_diagnostic_t *) error_list->head; error != finish; error = (pm_diagnostic_t *) error->node.next) {
10584 pm_line_column_t start = pm_newline_list_line_column(newline_list, error->location.start, start_line);
10585 pm_line_column_t end = pm_newline_list_line_column(newline_list, error->location.end, start_line);
10586
10587 // We're going to insert this error into the array in sorted order. We
10588 // do this by finding the first error that has a line number greater
10589 // than the current error and then inserting the current error before
10590 // that one.
10591 size_t index = 0;
10592 while (
10593 (index < error_list->size) &&
10594 (errors[index].error != NULL) &&
10595 (
10596 (errors[index].line < start.line) ||
10597 ((errors[index].line == start.line) && (errors[index].column_start < start.column))
10598 )
10599 ) index++;
10600
10601 // Now we're going to shift all of the errors after this one down one
10602 // index to make room for the new error.
10603 if (index + 1 < error_list->size) {
10604 memmove(&errors[index + 1], &errors[index], sizeof(pm_parse_error_t) * (error_list->size - index - 1));
10605 }
10606
10607 // Finally, we'll insert the error into the array.
10608 uint32_t column_end;
10609 if (start.line == end.line) {
10610 column_end = end.column;
10611 } else {
10612 column_end = (uint32_t) (newline_list->offsets[start.line - start_line + 1] - newline_list->offsets[start.line - start_line] - 1);
10613 }
10614
10615 // Ensure we have at least one column of error.
10616 if (start.column == column_end) column_end++;
10617
10618 errors[index] = (pm_parse_error_t) {
10619 .error = error,
10620 .line = start.line,
10621 .column_start = start.column,
10622 .column_end = column_end
10623 };
10624 }
10625
10626 return errors;
10627}
10628
10629/* Append a literal string to the buffer. */
10630#define pm_buffer_append_literal(buffer, str) pm_buffer_append_string(buffer, str, rb_strlen_lit(str))
10631
10632static inline void
10633pm_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) {
10634 int32_t line_delta = line - parser->start_line;
10635 assert(line_delta >= 0);
10636
10637 size_t index = (size_t) line_delta;
10638 assert(index < newline_list->size);
10639
10640 const uint8_t *start = &parser->start[newline_list->offsets[index]];
10641 const uint8_t *end;
10642
10643 if (index >= newline_list->size - 1) {
10644 end = parser->end;
10645 } else {
10646 end = &parser->start[newline_list->offsets[index + 1]];
10647 }
10648
10649 pm_buffer_append_format(buffer, number_prefix, line);
10650
10651 // Here we determine if we should truncate the end of the line.
10652 bool truncate_end = false;
10653 if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
10654 const uint8_t *end_candidate = start + column_end + PM_ERROR_TRUNCATE;
10655
10656 for (const uint8_t *ptr = start; ptr < end_candidate;) {
10657 size_t char_width = parser->encoding->char_width(ptr, parser->end - ptr);
10658
10659 // If we failed to decode a character, then just bail out and
10660 // truncate at the fixed width.
10661 if (char_width == 0) break;
10662
10663 // If this next character would go past the end candidate,
10664 // then we need to truncate before it.
10665 if (ptr + char_width > end_candidate) {
10666 end_candidate = ptr;
10667 break;
10668 }
10669
10670 ptr += char_width;
10671 }
10672
10673 end = end_candidate;
10674 truncate_end = true;
10675 }
10676
10677 // Here we determine if we should truncate the start of the line.
10678 if (column_start >= PM_ERROR_TRUNCATE) {
10679 pm_buffer_append_string(buffer, "... ", 4);
10680 start += column_start;
10681 }
10682
10683 pm_buffer_append_string(buffer, (const char *) start, (size_t) (end - start));
10684
10685 if (truncate_end) {
10686 pm_buffer_append_string(buffer, " ...\n", 5);
10687 } else if (end == parser->end && end[-1] != '\n') {
10688 pm_buffer_append_string(buffer, "\n", 1);
10689 }
10690}
10691
10695static void
10696pm_parse_errors_format(const pm_parser_t *parser, const pm_list_t *error_list, pm_buffer_t *buffer, int highlight, bool inline_messages) {
10697 assert(error_list->size != 0);
10698
10699 // First, we're going to sort all of the errors by line number using an
10700 // insertion sort into a newly allocated array.
10701 const int32_t start_line = parser->start_line;
10702 const pm_newline_list_t *newline_list = &parser->newline_list;
10703
10704 pm_parse_error_t *errors = pm_parse_errors_format_sort(parser, error_list, newline_list);
10705 if (errors == NULL) return;
10706
10707 // Now we're going to determine how we're going to format line numbers and
10708 // blank lines based on the maximum number of digits in the line numbers
10709 // that are going to be displaid.
10710 pm_parse_error_format_t error_format;
10711 int32_t first_line_number = errors[0].line;
10712 int32_t last_line_number = errors[error_list->size - 1].line;
10713
10714 // If we have a maximum line number that is negative, then we're going to
10715 // use the absolute value for comparison but multiple by 10 to additionally
10716 // have a column for the negative sign.
10717 if (first_line_number < 0) first_line_number = (-first_line_number) * 10;
10718 if (last_line_number < 0) last_line_number = (-last_line_number) * 10;
10719 int32_t max_line_number = first_line_number > last_line_number ? first_line_number : last_line_number;
10720
10721 if (max_line_number < 10) {
10722 if (highlight > 0) {
10723 error_format = (pm_parse_error_format_t) {
10724 .number_prefix = PM_COLOR_GRAY "%1" PRIi32 " | " PM_COLOR_RESET,
10725 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10726 .divider = PM_COLOR_GRAY " ~~~~~" PM_COLOR_RESET "\n"
10727 };
10728 } else {
10729 error_format = (pm_parse_error_format_t) {
10730 .number_prefix = "%1" PRIi32 " | ",
10731 .blank_prefix = " | ",
10732 .divider = " ~~~~~\n"
10733 };
10734 }
10735 } else if (max_line_number < 100) {
10736 if (highlight > 0) {
10737 error_format = (pm_parse_error_format_t) {
10738 .number_prefix = PM_COLOR_GRAY "%2" PRIi32 " | " PM_COLOR_RESET,
10739 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10740 .divider = PM_COLOR_GRAY " ~~~~~~" PM_COLOR_RESET "\n"
10741 };
10742 } else {
10743 error_format = (pm_parse_error_format_t) {
10744 .number_prefix = "%2" PRIi32 " | ",
10745 .blank_prefix = " | ",
10746 .divider = " ~~~~~~\n"
10747 };
10748 }
10749 } else if (max_line_number < 1000) {
10750 if (highlight > 0) {
10751 error_format = (pm_parse_error_format_t) {
10752 .number_prefix = PM_COLOR_GRAY "%3" PRIi32 " | " PM_COLOR_RESET,
10753 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10754 .divider = PM_COLOR_GRAY " ~~~~~~~" PM_COLOR_RESET "\n"
10755 };
10756 } else {
10757 error_format = (pm_parse_error_format_t) {
10758 .number_prefix = "%3" PRIi32 " | ",
10759 .blank_prefix = " | ",
10760 .divider = " ~~~~~~~\n"
10761 };
10762 }
10763 } else if (max_line_number < 10000) {
10764 if (highlight > 0) {
10765 error_format = (pm_parse_error_format_t) {
10766 .number_prefix = PM_COLOR_GRAY "%4" PRIi32 " | " PM_COLOR_RESET,
10767 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10768 .divider = PM_COLOR_GRAY " ~~~~~~~~" PM_COLOR_RESET "\n"
10769 };
10770 } else {
10771 error_format = (pm_parse_error_format_t) {
10772 .number_prefix = "%4" PRIi32 " | ",
10773 .blank_prefix = " | ",
10774 .divider = " ~~~~~~~~\n"
10775 };
10776 }
10777 } else {
10778 if (highlight > 0) {
10779 error_format = (pm_parse_error_format_t) {
10780 .number_prefix = PM_COLOR_GRAY "%5" PRIi32 " | " PM_COLOR_RESET,
10781 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10782 .divider = PM_COLOR_GRAY " ~~~~~~~~" PM_COLOR_RESET "\n"
10783 };
10784 } else {
10785 error_format = (pm_parse_error_format_t) {
10786 .number_prefix = "%5" PRIi32 " | ",
10787 .blank_prefix = " | ",
10788 .divider = " ~~~~~~~~\n"
10789 };
10790 }
10791 }
10792
10793 error_format.blank_prefix_length = strlen(error_format.blank_prefix);
10794 error_format.divider_length = strlen(error_format.divider);
10795
10796 // Now we're going to iterate through every error in our error list and
10797 // display it. While we're iterating, we will display some padding lines of
10798 // the source before the error to give some context. We'll be careful not to
10799 // display the same line twice in case the errors are close enough in the
10800 // source.
10801 int32_t last_line = parser->start_line - 1;
10802 uint32_t last_column_start = 0;
10803 const pm_encoding_t *encoding = parser->encoding;
10804
10805 for (size_t index = 0; index < error_list->size; index++) {
10806 pm_parse_error_t *error = &errors[index];
10807
10808 // Here we determine how many lines of padding of the source to display,
10809 // based on the difference from the last line that was displaid.
10810 if (error->line - last_line > 1) {
10811 if (error->line - last_line > 2) {
10812 if ((index != 0) && (error->line - last_line > 3)) {
10813 pm_buffer_append_string(buffer, error_format.divider, error_format.divider_length);
10814 }
10815
10816 pm_buffer_append_string(buffer, " ", 2);
10817 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 2, 0, 0, buffer);
10818 }
10819
10820 pm_buffer_append_string(buffer, " ", 2);
10821 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 1, 0, 0, buffer);
10822 }
10823
10824 // If this is the first error or we're on a new line, then we'll display
10825 // the line that has the error in it.
10826 if ((index == 0) || (error->line != last_line)) {
10827 if (highlight > 1) {
10828 pm_buffer_append_literal(buffer, PM_COLOR_RED "> " PM_COLOR_RESET);
10829 } else if (highlight > 0) {
10830 pm_buffer_append_literal(buffer, PM_COLOR_BOLD "> " PM_COLOR_RESET);
10831 } else {
10832 pm_buffer_append_literal(buffer, "> ");
10833 }
10834
10835 last_column_start = error->column_start;
10836
10837 // Find the maximum column end of all the errors on this line.
10838 uint32_t column_end = error->column_end;
10839 for (size_t next_index = index + 1; next_index < error_list->size; next_index++) {
10840 if (errors[next_index].line != error->line) break;
10841 if (errors[next_index].column_end > column_end) column_end = errors[next_index].column_end;
10842 }
10843
10844 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line, error->column_start, column_end, buffer);
10845 }
10846
10847 const uint8_t *start = &parser->start[newline_list->offsets[error->line - start_line]];
10848 if (start == parser->end) pm_buffer_append_byte(buffer, '\n');
10849
10850 // Now we'll display the actual error message. We'll do this by first
10851 // putting the prefix to the line, then a bunch of blank spaces
10852 // depending on the column, then as many carets as we need to display
10853 // the width of the error, then the error message itself.
10854 //
10855 // Note that this doesn't take into account the width of the actual
10856 // character when displaid in the terminal. For some east-asian
10857 // languages or emoji, this means it can be thrown off pretty badly. We
10858 // will need to solve this eventually.
10859 pm_buffer_append_string(buffer, " ", 2);
10860 pm_buffer_append_string(buffer, error_format.blank_prefix, error_format.blank_prefix_length);
10861
10862 size_t column = 0;
10863 if (last_column_start >= PM_ERROR_TRUNCATE) {
10864 pm_buffer_append_string(buffer, " ", 4);
10865 column = last_column_start;
10866 }
10867
10868 while (column < error->column_start) {
10869 pm_buffer_append_byte(buffer, ' ');
10870
10871 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10872 column += (char_width == 0 ? 1 : char_width);
10873 }
10874
10875 if (highlight > 1) pm_buffer_append_literal(buffer, PM_COLOR_RED);
10876 else if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_BOLD);
10877 pm_buffer_append_byte(buffer, '^');
10878
10879 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10880 column += (char_width == 0 ? 1 : char_width);
10881
10882 while (column < error->column_end) {
10883 pm_buffer_append_byte(buffer, '~');
10884
10885 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10886 column += (char_width == 0 ? 1 : char_width);
10887 }
10888
10889 if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_RESET);
10890
10891 if (inline_messages) {
10892 pm_buffer_append_byte(buffer, ' ');
10893 assert(error->error != NULL);
10894
10895 const char *message = error->error->message;
10896 pm_buffer_append_string(buffer, message, strlen(message));
10897 }
10898
10899 pm_buffer_append_byte(buffer, '\n');
10900
10901 // Here we determine how many lines of padding to display after the
10902 // error, depending on where the next error is in source.
10903 last_line = error->line;
10904 int32_t next_line;
10905
10906 if (index == error_list->size - 1) {
10907 next_line = (((int32_t) newline_list->size) + parser->start_line);
10908
10909 // If the file ends with a newline, subtract one from our "next_line"
10910 // so that we don't output an extra line at the end of the file
10911 if ((parser->start + newline_list->offsets[newline_list->size - 1]) == parser->end) {
10912 next_line--;
10913 }
10914 }
10915 else {
10916 next_line = errors[index + 1].line;
10917 }
10918
10919 if (next_line - last_line > 1) {
10920 pm_buffer_append_string(buffer, " ", 2);
10921 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
10922 }
10923
10924 if (next_line - last_line > 1) {
10925 pm_buffer_append_string(buffer, " ", 2);
10926 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
10927 }
10928 }
10929
10930 // Finally, we'll free the array of errors that we allocated.
10931 xfree(errors);
10932}
10933
10934#undef PM_ERROR_TRUNCATE
10935#undef PM_COLOR_GRAY
10936#undef PM_COLOR_RED
10937#undef PM_COLOR_RESET
10938
10945static bool
10946pm_parse_process_error_utf8_p(const pm_parser_t *parser, const pm_location_t *location)
10947{
10948 const size_t start_line = pm_newline_list_line_column(&parser->newline_list, location->start, 1).line;
10949 const size_t end_line = pm_newline_list_line_column(&parser->newline_list, location->end, 1).line;
10950
10951 const uint8_t *start = parser->start + parser->newline_list.offsets[start_line - 1];
10952 const uint8_t *end = ((end_line == parser->newline_list.size) ? parser->end : (parser->start + parser->newline_list.offsets[end_line]));
10953 size_t width;
10954
10955 while (start < end) {
10956 if ((width = pm_encoding_utf_8_char_width(start, end - start)) == 0) return false;
10957 start += width;
10958 }
10959
10960 return true;
10961}
10962
10967static VALUE
10968pm_parse_process_error(const pm_parse_result_t *result)
10969{
10970 const pm_parser_t *parser = &result->parser;
10971 const pm_diagnostic_t *head = (const pm_diagnostic_t *) parser->error_list.head;
10972 bool valid_utf8 = true;
10973
10974 pm_buffer_t buffer = { 0 };
10975 const pm_string_t *filepath = &parser->filepath;
10976
10977 int highlight = rb_stderr_tty_p();
10978 if (highlight) {
10979 const char *no_color = getenv("NO_COLOR");
10980 highlight = (no_color == NULL || no_color[0] == '\0') ? 2 : 1;
10981 }
10982
10983 for (const pm_diagnostic_t *error = head; error != NULL; error = (const pm_diagnostic_t *) error->node.next) {
10984 switch (error->level) {
10985 case PM_ERROR_LEVEL_SYNTAX:
10986 // It is implicitly assumed that the error messages will be
10987 // encodeable as UTF-8. Because of this, we can't include source
10988 // examples that contain invalid byte sequences. So if any source
10989 // examples include invalid UTF-8 byte sequences, we will skip
10990 // showing source examples entirely.
10991 if (valid_utf8 && !pm_parse_process_error_utf8_p(parser, &error->location)) {
10992 valid_utf8 = false;
10993 }
10994 break;
10995 case PM_ERROR_LEVEL_ARGUMENT: {
10996 // Any errors with the level PM_ERROR_LEVEL_ARGUMENT take over as
10997 // the only argument that gets raised. This is to allow priority
10998 // messages that should be handled before anything else.
10999 int32_t line_number = (int32_t) pm_location_line_number(parser, &error->location);
11000
11001 pm_buffer_append_format(
11002 &buffer,
11003 "%.*s:%" PRIi32 ": %s",
11004 (int) pm_string_length(filepath),
11005 pm_string_source(filepath),
11006 line_number,
11007 error->message
11008 );
11009
11010 if (pm_parse_process_error_utf8_p(parser, &error->location)) {
11011 pm_buffer_append_byte(&buffer, '\n');
11012
11013 pm_list_node_t *list_node = (pm_list_node_t *) error;
11014 pm_list_t error_list = { .size = 1, .head = list_node, .tail = list_node };
11015
11016 pm_parse_errors_format(parser, &error_list, &buffer, highlight, false);
11017 }
11018
11019 VALUE value = rb_exc_new(rb_eArgError, pm_buffer_value(&buffer), pm_buffer_length(&buffer));
11020 pm_buffer_free(&buffer);
11021
11022 return value;
11023 }
11024 case PM_ERROR_LEVEL_LOAD: {
11025 // Load errors are much simpler, because they don't include any of
11026 // the source in them. We create the error directly from the
11027 // message.
11028 VALUE message = rb_enc_str_new_cstr(error->message, rb_locale_encoding());
11029 VALUE value = rb_exc_new3(rb_eLoadError, message);
11030 rb_ivar_set(value, rb_intern_const("@path"), Qnil);
11031 return value;
11032 }
11033 }
11034 }
11035
11036 pm_buffer_append_format(
11037 &buffer,
11038 "%.*s:%" PRIi32 ": syntax error%s found\n",
11039 (int) pm_string_length(filepath),
11040 pm_string_source(filepath),
11041 (int32_t) pm_location_line_number(parser, &head->location),
11042 (parser->error_list.size > 1) ? "s" : ""
11043 );
11044
11045 if (valid_utf8) {
11046 pm_parse_errors_format(parser, &parser->error_list, &buffer, highlight, true);
11047 }
11048 else {
11049 for (const pm_diagnostic_t *error = head; error != NULL; error = (const pm_diagnostic_t *) error->node.next) {
11050 if (error != head) pm_buffer_append_byte(&buffer, '\n');
11051 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);
11052 }
11053 }
11054
11055 VALUE message = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), result->node.encoding);
11056 VALUE error = rb_exc_new_str(rb_eSyntaxError, message);
11057
11058 rb_encoding *filepath_encoding = result->node.filepath_encoding != NULL ? result->node.filepath_encoding : rb_utf8_encoding();
11059 VALUE path = rb_enc_str_new((const char *) pm_string_source(filepath), pm_string_length(filepath), filepath_encoding);
11060
11061 rb_ivar_set(error, rb_intern_const("@path"), path);
11062 pm_buffer_free(&buffer);
11063
11064 return error;
11065}
11066
11072static VALUE
11073pm_parse_process(pm_parse_result_t *result, pm_node_t *node, VALUE *script_lines)
11074{
11075 pm_parser_t *parser = &result->parser;
11076
11077 // First, set up the scope node so that the AST node is attached and can be
11078 // freed regardless of whether or we return an error.
11079 pm_scope_node_t *scope_node = &result->node;
11080 rb_encoding *filepath_encoding = scope_node->filepath_encoding;
11081 int coverage_enabled = scope_node->coverage_enabled;
11082
11083 pm_scope_node_init(node, scope_node, NULL);
11084 scope_node->filepath_encoding = filepath_encoding;
11085
11086 scope_node->encoding = rb_enc_find(parser->encoding->name);
11087 if (!scope_node->encoding) rb_bug("Encoding not found %s!", parser->encoding->name);
11088
11089 scope_node->coverage_enabled = coverage_enabled;
11090
11091 // If RubyVM.keep_script_lines is set to true, then we need to create that
11092 // array of script lines here.
11093 if (script_lines != NULL) {
11094 *script_lines = rb_ary_new_capa(parser->newline_list.size);
11095
11096 for (size_t index = 0; index < parser->newline_list.size; index++) {
11097 size_t offset = parser->newline_list.offsets[index];
11098 size_t length = index == parser->newline_list.size - 1 ? ((size_t) (parser->end - (parser->start + offset))) : (parser->newline_list.offsets[index + 1] - offset);
11099 rb_ary_push(*script_lines, rb_enc_str_new((const char *) parser->start + offset, length, scope_node->encoding));
11100 }
11101
11102 scope_node->script_lines = script_lines;
11103 }
11104
11105 // Emit all of the various warnings from the parse.
11106 const pm_diagnostic_t *warning;
11107 const char *warning_filepath = (const char *) pm_string_source(&parser->filepath);
11108
11109 for (warning = (const pm_diagnostic_t *) parser->warning_list.head; warning != NULL; warning = (const pm_diagnostic_t *) warning->node.next) {
11110 int line = pm_location_line_number(parser, &warning->location);
11111
11112 if (warning->level == PM_WARNING_LEVEL_VERBOSE) {
11113 rb_enc_compile_warning(scope_node->encoding, warning_filepath, line, "%s", warning->message);
11114 }
11115 else {
11116 rb_enc_compile_warn(scope_node->encoding, warning_filepath, line, "%s", warning->message);
11117 }
11118 }
11119
11120 // If there are errors, raise an appropriate error and free the result.
11121 if (parser->error_list.size > 0) {
11122 VALUE error = pm_parse_process_error(result);
11123
11124 // TODO: We need to set the backtrace.
11125 // rb_funcallv(error, rb_intern("set_backtrace"), 1, &path);
11126 return error;
11127 }
11128
11129 // Now set up the constant pool and intern all of the various constants into
11130 // their corresponding IDs.
11131 scope_node->parser = parser;
11132 scope_node->constants = parser->constant_pool.size ? xcalloc(parser->constant_pool.size, sizeof(ID)) : NULL;
11133
11134 for (uint32_t index = 0; index < parser->constant_pool.size; index++) {
11135 pm_constant_t *constant = &parser->constant_pool.constants[index];
11136 scope_node->constants[index] = rb_intern3((const char *) constant->start, constant->length, scope_node->encoding);
11137 }
11138
11139 scope_node->index_lookup_table = st_init_numtable();
11140 pm_constant_id_list_t *locals = &scope_node->locals;
11141 for (size_t index = 0; index < locals->size; index++) {
11142 st_insert(scope_node->index_lookup_table, locals->ids[index], index);
11143 }
11144
11145 // If we got here, this is a success and we can return Qnil to indicate that
11146 // no error should be raised.
11147 result->parsed = true;
11148 return Qnil;
11149}
11150
11155static void
11156pm_options_frozen_string_literal_init(pm_options_t *options)
11157{
11158 int frozen_string_literal = rb_iseq_opt_frozen_string_literal();
11159
11160 switch (frozen_string_literal) {
11161 case ISEQ_FROZEN_STRING_LITERAL_UNSET:
11162 break;
11163 case ISEQ_FROZEN_STRING_LITERAL_DISABLED:
11164 pm_options_frozen_string_literal_set(options, false);
11165 break;
11166 case ISEQ_FROZEN_STRING_LITERAL_ENABLED:
11167 pm_options_frozen_string_literal_set(options, true);
11168 break;
11169 default:
11170 rb_bug("pm_options_frozen_string_literal_init: invalid frozen_string_literal=%d", frozen_string_literal);
11171 break;
11172 }
11173}
11174
11179static inline VALUE
11180pm_parse_file_script_lines(const pm_scope_node_t *scope_node, const pm_parser_t *parser)
11181{
11182 const pm_newline_list_t *newline_list = &parser->newline_list;
11183 const char *start = (const char *) parser->start;
11184 const char *end = (const char *) parser->end;
11185
11186 // If we end exactly on a newline, then there's no need to push on a final
11187 // segment. If we don't, then we need to push on the last offset up to the
11188 // end of the string.
11189 size_t last_offset = newline_list->offsets[newline_list->size - 1];
11190 bool last_push = start + last_offset != end;
11191
11192 // Create the ruby strings that represent the lines of the source.
11193 VALUE lines = rb_ary_new_capa(newline_list->size - (last_push ? 0 : 1));
11194
11195 for (size_t index = 0; index < newline_list->size - 1; index++) {
11196 size_t offset = newline_list->offsets[index];
11197 size_t length = newline_list->offsets[index + 1] - offset;
11198
11199 rb_ary_push(lines, rb_enc_str_new(start + offset, length, scope_node->encoding));
11200 }
11201
11202 // Push on the last line if we need to.
11203 if (last_push) {
11204 rb_ary_push(lines, rb_enc_str_new(start + last_offset, end - (start + last_offset), scope_node->encoding));
11205 }
11206
11207 return lines;
11208}
11209
11210// This is essentially pm_string_mapped_init(), preferring to memory map the
11211// file, with additional handling for files that require blocking to properly
11212// read (e.g. pipes).
11213static pm_string_init_result_t
11214pm_read_file(pm_string_t *string, const char *filepath)
11215{
11216#ifdef _WIN32
11217 // Open the file for reading.
11218 int length = MultiByteToWideChar(CP_UTF8, 0, filepath, -1, NULL, 0);
11219 if (length == 0) return PM_STRING_INIT_ERROR_GENERIC;
11220
11221 WCHAR *wfilepath = xmalloc(sizeof(WCHAR) * ((size_t) length));
11222 if ((wfilepath == NULL) || (MultiByteToWideChar(CP_UTF8, 0, filepath, -1, wfilepath, length) == 0)) {
11223 xfree(wfilepath);
11224 return PM_STRING_INIT_ERROR_GENERIC;
11225 }
11226
11227 HANDLE file = CreateFileW(wfilepath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
11228 if (file == INVALID_HANDLE_VALUE) {
11229 pm_string_init_result_t result = PM_STRING_INIT_ERROR_GENERIC;
11230
11231 if (GetLastError() == ERROR_ACCESS_DENIED) {
11232 DWORD attributes = GetFileAttributesW(wfilepath);
11233 if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
11234 result = PM_STRING_INIT_ERROR_DIRECTORY;
11235 }
11236 }
11237
11238 xfree(wfilepath);
11239 return result;
11240 }
11241
11242 // Get the file size.
11243 DWORD file_size = GetFileSize(file, NULL);
11244 if (file_size == INVALID_FILE_SIZE) {
11245 CloseHandle(file);
11246 xfree(wfilepath);
11247 return PM_STRING_INIT_ERROR_GENERIC;
11248 }
11249
11250 // If the file is empty, then we don't need to do anything else, we'll set
11251 // the source to a constant empty string and return.
11252 if (file_size == 0) {
11253 CloseHandle(file);
11254 xfree(wfilepath);
11255 const uint8_t source[] = "";
11256 *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11257 return PM_STRING_INIT_SUCCESS;
11258 }
11259
11260 // Create a mapping of the file.
11261 HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
11262 if (mapping == NULL) {
11263 CloseHandle(file);
11264 xfree(wfilepath);
11265 return PM_STRING_INIT_ERROR_GENERIC;
11266 }
11267
11268 // Map the file into memory.
11269 uint8_t *source = (uint8_t *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
11270 CloseHandle(mapping);
11271 CloseHandle(file);
11272 xfree(wfilepath);
11273
11274 if (source == NULL) {
11275 return PM_STRING_INIT_ERROR_GENERIC;
11276 }
11277
11278 *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = (size_t) file_size };
11279 return PM_STRING_INIT_SUCCESS;
11280#elif defined(_POSIX_MAPPED_FILES)
11281 // Open the file for reading
11282 const int open_mode = O_RDONLY | O_NONBLOCK;
11283 int fd = open(filepath, open_mode);
11284 if (fd == -1) {
11285 return PM_STRING_INIT_ERROR_GENERIC;
11286 }
11287
11288 // Stat the file to get the file size
11289 struct stat sb;
11290 if (fstat(fd, &sb) == -1) {
11291 close(fd);
11292 return PM_STRING_INIT_ERROR_GENERIC;
11293 }
11294
11295 // Ensure it is a file and not a directory
11296 if (S_ISDIR(sb.st_mode)) {
11297 close(fd);
11298 return PM_STRING_INIT_ERROR_DIRECTORY;
11299 }
11300
11301 // We need to wait for data first before reading from pipes and character
11302 // devices. To not block the entire VM, we need to release the GVL while
11303 // reading. Use IO#read to do this and let the GC handle closing the FD.
11304 if (S_ISFIFO(sb.st_mode) || S_ISCHR(sb.st_mode)) {
11305 VALUE io = rb_io_fdopen((int) fd, open_mode, filepath);
11306 rb_io_wait(io, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
11307 VALUE contents = rb_funcall(io, rb_intern("read"), 0);
11308
11309 if (!RB_TYPE_P(contents, T_STRING)) {
11310 return PM_STRING_INIT_ERROR_GENERIC;
11311 }
11312
11313 long len = RSTRING_LEN(contents);
11314 if (len < 0) {
11315 return PM_STRING_INIT_ERROR_GENERIC;
11316 }
11317
11318 size_t length = (size_t) len;
11319 uint8_t *source = malloc(length);
11320 memcpy(source, RSTRING_PTR(contents), length);
11321 *string = (pm_string_t) { .type = PM_STRING_OWNED, .source = source, .length = length };
11322
11323 return PM_STRING_INIT_SUCCESS;
11324 }
11325
11326 // mmap the file descriptor to virtually get the contents
11327 size_t size = (size_t) sb.st_size;
11328 uint8_t *source = NULL;
11329
11330 if (size == 0) {
11331 close(fd);
11332 const uint8_t source[] = "";
11333 *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11334 return PM_STRING_INIT_SUCCESS;
11335 }
11336
11337 source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
11338 if (source == MAP_FAILED) {
11339 close(fd);
11340 return PM_STRING_INIT_ERROR_GENERIC;
11341 }
11342
11343 close(fd);
11344 *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = size };
11345 return PM_STRING_INIT_SUCCESS;
11346#else
11347 return pm_string_file_init(string, filepath);
11348#endif
11349}
11350
11355 VALUE
11356pm_load_file(pm_parse_result_t *result, VALUE filepath, bool load_error)
11357{
11358 pm_string_init_result_t init_result = pm_read_file(&result->input, RSTRING_PTR(filepath));
11359
11360 if (init_result == PM_STRING_INIT_SUCCESS) {
11361 pm_options_frozen_string_literal_init(&result->options);
11362 return Qnil;
11363 }
11364
11365 int err;
11366 if (init_result == PM_STRING_INIT_ERROR_DIRECTORY) {
11367 err = EISDIR;
11368 } else {
11369#ifdef _WIN32
11370 err = rb_w32_map_errno(GetLastError());
11371#else
11372 err = errno;
11373#endif
11374 }
11375
11376 VALUE error;
11377 if (load_error) {
11378 VALUE message = rb_str_buf_new_cstr(strerror(err));
11379 rb_str_cat2(message, " -- ");
11380 rb_str_append(message, filepath);
11381
11382 error = rb_exc_new3(rb_eLoadError, message);
11383 rb_ivar_set(error, rb_intern_const("@path"), filepath);
11384 } else {
11385 error = rb_syserr_new(err, RSTRING_PTR(filepath));
11386 RB_GC_GUARD(filepath);
11387 }
11388
11389 return error;
11390}
11391
11398 VALUE
11399pm_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
11400{
11401 result->node.filepath_encoding = rb_enc_get(filepath);
11402 pm_options_filepath_set(&result->options, RSTRING_PTR(filepath));
11403 RB_GC_GUARD(filepath);
11404
11405 pm_options_version_for_current_ruby_set(&result->options);
11406
11407 pm_parser_init(&result->parser, pm_string_source(&result->input), pm_string_length(&result->input), &result->options);
11408 pm_node_t *node = pm_parse(&result->parser);
11409
11410 VALUE error = pm_parse_process(result, node, script_lines);
11411
11412 // If we're parsing a filepath, then we need to potentially support the
11413 // SCRIPT_LINES__ constant, which can be a hash that has an array of lines
11414 // of every read file.
11415 ID id_script_lines = rb_intern("SCRIPT_LINES__");
11416
11417 if (rb_const_defined_at(rb_cObject, id_script_lines)) {
11418 VALUE constant_script_lines = rb_const_get_at(rb_cObject, id_script_lines);
11419
11420 if (RB_TYPE_P(constant_script_lines, T_HASH)) {
11421 rb_hash_aset(constant_script_lines, filepath, pm_parse_file_script_lines(&result->node, &result->parser));
11422 }
11423 }
11424
11425 return error;
11426}
11427
11432 VALUE
11433pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
11434{
11435 VALUE error = pm_load_file(result, filepath, false);
11436 if (NIL_P(error)) {
11437 error = pm_parse_file(result, filepath, script_lines);
11438 }
11439
11440 return error;
11441}
11442
11449 VALUE
11450pm_parse_string(pm_parse_result_t *result, VALUE source, VALUE filepath, VALUE *script_lines)
11451{
11452 rb_encoding *encoding = rb_enc_get(source);
11453 if (!rb_enc_asciicompat(encoding)) {
11454 return rb_exc_new_cstr(rb_eArgError, "invalid source encoding");
11455 }
11456
11457 pm_options_frozen_string_literal_init(&result->options);
11458 pm_string_constant_init(&result->input, RSTRING_PTR(source), RSTRING_LEN(source));
11459 pm_options_encoding_set(&result->options, rb_enc_name(encoding));
11460
11461 result->node.filepath_encoding = rb_enc_get(filepath);
11462 pm_options_filepath_set(&result->options, RSTRING_PTR(filepath));
11463 RB_GC_GUARD(filepath);
11464
11465 pm_options_version_for_current_ruby_set(&result->options);
11466
11467 pm_parser_init(&result->parser, pm_string_source(&result->input), pm_string_length(&result->input), &result->options);
11468 pm_node_t *node = pm_parse(&result->parser);
11469
11470 return pm_parse_process(result, node, script_lines);
11471}
11472
11473 struct rb_stdin_wrapper {
11474 VALUE rb_stdin;
11475 int eof_seen;
11476};
11477
11478static int
11479pm_parse_stdin_eof(void *stream)
11480{
11481 struct rb_stdin_wrapper * wrapped_stdin = (struct rb_stdin_wrapper *)stream;
11482 return wrapped_stdin->eof_seen;
11483}
11484
11485 VALUE rb_io_gets_limit_internal(VALUE io, long limit);
11486
11490static char *
11491pm_parse_stdin_fgets(char *string, int size, void *stream)
11492{
11493 RUBY_ASSERT(size > 0);
11494
11495 struct rb_stdin_wrapper * wrapped_stdin = (struct rb_stdin_wrapper *)stream;
11496
11497 VALUE line = rb_io_gets_limit_internal(wrapped_stdin->rb_stdin, size - 1);
11498 if (NIL_P(line)) {
11499 return NULL;
11500 }
11501
11502 const char *cstr = RSTRING_PTR(line);
11503 long length = RSTRING_LEN(line);
11504
11505 memcpy(string, cstr, length);
11506 string[length] = '\0';
11507
11508 // We're reading strings from stdin via gets. We'll assume that if the
11509 // string is smaller than the requested length, and doesn't end with a
11510 // newline, that we hit EOF.
11511 if (length < (size - 1) && string[length - 1] != '\n') {
11512 wrapped_stdin->eof_seen = 1;
11513 }
11514
11515 return string;
11516}
11517
11518// We need access to this function when we're done parsing stdin.
11519void rb_reset_argf_lineno(long n);
11520
11526 VALUE
11527pm_parse_stdin(pm_parse_result_t *result)
11528{
11529 pm_options_frozen_string_literal_init(&result->options);
11530
11531 struct rb_stdin_wrapper wrapped_stdin = {
11532 rb_stdin,
11533 0
11534 };
11535
11536 pm_buffer_t buffer;
11537 pm_node_t *node = pm_parse_stream(&result->parser, &buffer, (void *) &wrapped_stdin, pm_parse_stdin_fgets, pm_parse_stdin_eof, &result->options);
11538
11539 // Copy the allocated buffer contents into the input string so that it gets
11540 // freed. At this point we've handed over ownership, so we don't need to
11541 // free the buffer itself.
11542 pm_string_owned_init(&result->input, (uint8_t *) pm_buffer_value(&buffer), pm_buffer_length(&buffer));
11543
11544 // When we're done parsing, we reset $. because we don't want the fact that
11545 // we went through an IO object to be visible to the user.
11546 rb_reset_argf_lineno(0);
11547
11548 return pm_parse_process(result, node, NULL);
11549}
11550
11551#define PM_VERSION_FOR_RELEASE(major, minor) PM_VERSION_FOR_RELEASE_IMPL(major, minor)
11552#define PM_VERSION_FOR_RELEASE_IMPL(major, minor) PM_OPTIONS_VERSION_CRUBY_##major##_##minor
11553
11554void pm_options_version_for_current_ruby_set(pm_options_t *options) {
11555 options->version = PM_VERSION_FOR_RELEASE(RUBY_API_VERSION_MAJOR, RUBY_API_VERSION_MINOR);
11556}
11557
11558#undef NEW_ISEQ
11559#define NEW_ISEQ OLD_ISEQ
11560
11561#undef NEW_CHILD_ISEQ
11562#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:417
PM_ERROR_LEVEL_ARGUMENT
@ PM_ERROR_LEVEL_ARGUMENT
For errors that should raise an argument error.
Definition diagnostic.h:403
PM_ERROR_LEVEL_LOAD
@ PM_ERROR_LEVEL_LOAD
For errors that should raise a load error.
Definition diagnostic.h:406
PM_ERROR_LEVEL_SYNTAX
@ PM_ERROR_LEVEL_SYNTAX
For errors that should raise a syntax error.
Definition diagnostic.h:400
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:1676
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:1684
ID2SYM
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
SPECIAL_CONST_P
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
Definition special_consts.h:56
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
FLONUM_P
#define FLONUM_P
Old name of RB_FLONUM_P.
Definition special_consts.h:67
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:1441
rb_exc_raise
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
Definition eval.c:653
rb_eStandardError
VALUE rb_eStandardError
StandardError exception.
Definition error.c:1428
rb_eLoadError
VALUE rb_eLoadError
LoadError exception.
Definition error.c:1449
rb_eTypeError
VALUE rb_eTypeError
TypeError exception.
Definition error.c:1431
rb_eNoMatchingPatternError
VALUE rb_eNoMatchingPatternError
NoMatchingPatternError exception.
Definition error.c:1444
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:1469
rb_eNoMatchingPatternKeyError
VALUE rb_eNoMatchingPatternKeyError
NoMatchingPatternKeyError exception.
Definition error.c:1445
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:1482
rb_errinfo
VALUE rb_errinfo(void)
This is the same as $! in Ruby.
Definition eval.c:2045
rb_eSyntaxError
VALUE rb_eSyntaxError
SyntaxError exception.
Definition error.c:1448
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:3895
rb_cArray
VALUE rb_cArray
Array class.
rb_obj_hide
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
Definition object.c:100
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:1342
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:1535
rb_ascii8bit_encoding
rb_encoding * rb_ascii8bit_encoding(void)
Queries the encoding that represents ASCII-8BIT a.k.a.
Definition encoding.c:1523
rb_usascii_encoding
rb_encoding * rb_usascii_encoding(void)
Queries the encoding that represents US-ASCII.
Definition encoding.c:1547
rb_enc_str_coderange
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
Definition string.c:947
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:12728
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:1155
rb_funcall
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
Definition vm_eval.c:1117
rb_ary_cat
VALUE rb_ary_cat(VALUE ary, const VALUE *train, long len)
Destructively appends multiple elements at the end of the array.
rb_ary_new
VALUE rb_ary_new(void)
Allocates a new, empty array.
rb_ary_new_capa
VALUE rb_ary_new_capa(long capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
rb_ary_hidden_new
VALUE rb_ary_hidden_new(long capa)
Allocates a hidden (no class) empty array.
rb_ary_push
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
rb_ary_entry
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
rb_ary_join
VALUE rb_ary_join(VALUE ary, VALUE sep)
Recursively stringises the elements of the passed array, flattens that result, then joins the sequenc...
rb_ary_store
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
rb_hash_new
VALUE rb_hash_new(void)
Creates a new, empty hash object.
Definition hash.c:1464
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:9358
rb_range_new
VALUE rb_range_new(VALUE beg, VALUE end, int excl)
Creates a new Range.
Definition range.c:69
rb_rational_new
VALUE rb_rational_new(VALUE num, VALUE den)
Constructs a Rational, with reduction.
Definition rational.c:2000
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:3799
rb_str_tmp_new
VALUE rb_str_tmp_new(long len)
Allocates a "temporary" string.
Definition string.c:1746
rb_str_new
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
Definition string.h:1499
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:1671
rb_str_buf_new_cstr
#define rb_str_buf_new_cstr(str)
Identical to rb_str_new_cstr, except done differently.
Definition string.h:1640
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:4036
rb_str_freeze
VALUE rb_str_freeze(VALUE str)
This is the implementation of String#freeze.
Definition string.c:3280
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:1515
rb_obj_as_string
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
Definition string.c:1850
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:2030
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:3467
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:3799
rb_intern_const
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
Definition symbol.h:285
rb_id2sym
VALUE rb_id2sym(ID id)
Allocates an instance of rb_cSymbol that has the given id.
Definition symbol.c:974
rb_sym2str
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
Definition symbol.c:993
RUBY_IO_READABLE
@ RUBY_IO_READABLE
IO::READABLE
Definition io.h:97
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:1482
len
int len
Length of the buffer.
Definition io.h:8
RB_OBJ_SHAREABLE_P
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
Definition ractor.h:235
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:1547
DECIMAL_SIZE_OF
#define DECIMAL_SIZE_OF(expr)
An approximation of decimal representation size.
Definition util.h:48
version.h
RUBY_API_VERSION_MAJOR
#define RUBY_API_VERSION_MAJOR
Major version.
Definition version.h:64
RUBY_API_VERSION_MINOR
#define RUBY_API_VERSION_MINOR
Minor version.
Definition version.h:70
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:1603
ensure_range
Definition compile.c:114
iseq_compile_data_ensure_node_stack
Definition compile.c:120
pm_alias_global_variable_node::old_name
struct pm_node * old_name
AliasGlobalVariableNode::old_name.
Definition ast.h:1139
pm_alias_global_variable_node::new_name
struct pm_node * new_name
AliasGlobalVariableNode::new_name.
Definition ast.h:1129
pm_alias_method_node::old_name
struct pm_node * old_name
AliasMethodNode::old_name.
Definition ast.h:1199
pm_alias_method_node::new_name
struct pm_node * new_name
AliasMethodNode::new_name.
Definition ast.h:1183
pm_alternation_pattern_node::left
struct pm_node * left
AlternationPatternNode::left.
Definition ast.h:1237
pm_alternation_pattern_node::right
struct pm_node * right
AlternationPatternNode::right.
Definition ast.h:1247
pm_and_node::left
struct pm_node * left
AndNode::left.
Definition ast.h:1288
pm_and_node::right
struct pm_node * right
AndNode::right.
Definition ast.h:1301
pm_arguments_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1335
pm_arguments_node::arguments
struct pm_node_list arguments
ArgumentsNode::arguments.
Definition ast.h:1346
pm_array_node::elements
struct pm_node_list elements
ArrayNode::elements.
Definition ast.h:1374
pm_array_pattern_node::requireds
struct pm_node_list requireds
ArrayPatternNode::requireds.
Definition ast.h:1454
pm_array_pattern_node::rest
struct pm_node * rest
ArrayPatternNode::rest.
Definition ast.h:1464
pm_array_pattern_node::constant
struct pm_node * constant
ArrayPatternNode::constant.
Definition ast.h:1444
pm_array_pattern_node::posts
struct pm_node_list posts
ArrayPatternNode::posts.
Definition ast.h:1474
pm_assoc_node::value
struct pm_node * value
AssocNode::value.
Definition ast.h:1541
pm_assoc_node::key
struct pm_node * key
AssocNode::key.
Definition ast.h:1528
pm_assoc_splat_node::value
struct pm_node * value
AssocSplatNode::value.
Definition ast.h:1579
pm_back_reference_read_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1606
pm_begin_node::ensure_clause
struct pm_ensure_node * ensure_clause
BeginNode::ensure_clause.
Definition ast.h:1688
pm_begin_node::rescue_clause
struct pm_rescue_node * rescue_clause
BeginNode::rescue_clause.
Definition ast.h:1668
pm_begin_node::statements
struct pm_statements_node * statements
BeginNode::statements.
Definition ast.h:1658
pm_begin_node::else_clause
struct pm_else_node * else_clause
BeginNode::else_clause.
Definition ast.h:1678
pm_block_argument_node::expression
struct pm_node * expression
BlockArgumentNode::expression.
Definition ast.h:1726
pm_block_node::parameters
struct pm_node * parameters
BlockNode::parameters.
Definition ast.h:1809
pm_block_node::body
struct pm_node * body
BlockNode::body.
Definition ast.h:1819
pm_block_node::locals
pm_constant_id_list_t locals
BlockNode::locals.
Definition ast.h:1795
pm_break_node::arguments
struct pm_arguments_node * arguments
BreakNode::arguments.
Definition ast.h:1999
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:2103
pm_call_and_write_node::read_name
pm_constant_id_t read_name
CallAndWriteNode::read_name.
Definition ast.h:2073
pm_call_and_write_node::write_name
pm_constant_id_t write_name
CallAndWriteNode::write_name.
Definition ast.h:2083
pm_call_and_write_node::receiver
struct pm_node * receiver
CallAndWriteNode::receiver.
Definition ast.h:2043
pm_call_node::closing_loc
pm_location_t closing_loc
CallNode::closing_loc.
Definition ast.h:2220
pm_call_node::receiver
struct pm_node * receiver
CallNode::receiver.
Definition ast.h:2158
pm_call_node::name
pm_constant_id_t name
CallNode::name.
Definition ast.h:2181
pm_call_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2141
pm_call_node::message_loc
pm_location_t message_loc
CallNode::message_loc.
Definition ast.h:2191
pm_call_node::arguments
struct pm_arguments_node * arguments
CallNode::arguments.
Definition ast.h:2210
pm_call_node::block
struct pm_node * block
CallNode::block.
Definition ast.h:2243
pm_call_operator_write_node::read_name
pm_constant_id_t read_name
CallOperatorWriteNode::read_name.
Definition ast.h:2307
pm_call_operator_write_node::binary_operator
pm_constant_id_t binary_operator
CallOperatorWriteNode::binary_operator.
Definition ast.h:2327
pm_call_operator_write_node::receiver
struct pm_node * receiver
CallOperatorWriteNode::receiver.
Definition ast.h:2277
pm_call_operator_write_node::write_name
pm_constant_id_t write_name
CallOperatorWriteNode::write_name.
Definition ast.h:2317
pm_call_operator_write_node::value
struct pm_node * value
CallOperatorWriteNode::value.
Definition ast.h:2347
pm_call_or_write_node::receiver
struct pm_node * receiver
CallOrWriteNode::receiver.
Definition ast.h:2381
pm_call_or_write_node::value
struct pm_node * value
CallOrWriteNode::value.
Definition ast.h:2441
pm_call_or_write_node::write_name
pm_constant_id_t write_name
CallOrWriteNode::write_name.
Definition ast.h:2421
pm_call_or_write_node::read_name
pm_constant_id_t read_name
CallOrWriteNode::read_name.
Definition ast.h:2411
pm_call_target_node::name
pm_constant_id_t name
CallTargetNode::name.
Definition ast.h:2503
pm_call_target_node::receiver
struct pm_node * receiver
CallTargetNode::receiver.
Definition ast.h:2483
pm_capture_pattern_node::target
struct pm_local_variable_target_node * target
CapturePatternNode::target.
Definition ast.h:2551
pm_capture_pattern_node::value
struct pm_node * value
CapturePatternNode::value.
Definition ast.h:2541
pm_case_match_node::conditions
struct pm_node_list conditions
CaseMatchNode::conditions.
Definition ast.h:2601
pm_case_match_node::else_clause
struct pm_else_node * else_clause
CaseMatchNode::else_clause.
Definition ast.h:2611
pm_case_match_node::predicate
struct pm_node * predicate
CaseMatchNode::predicate.
Definition ast.h:2591
pm_case_node::predicate
struct pm_node * predicate
CaseNode::predicate.
Definition ast.h:2661
pm_case_node::else_clause
struct pm_else_node * else_clause
CaseNode::else_clause.
Definition ast.h:2681
pm_case_node::conditions
struct pm_node_list conditions
CaseNode::conditions.
Definition ast.h:2671
pm_class_node::constant_path
struct pm_node * constant_path
ClassNode::constant_path.
Definition ast.h:2739
pm_class_node::locals
pm_constant_id_list_t locals
ClassNode::locals.
Definition ast.h:2724
pm_class_node::name
pm_constant_id_t name
ClassNode::name.
Definition ast.h:2789
pm_class_node::body
struct pm_node * body
ClassNode::body.
Definition ast.h:2770
pm_class_node::superclass
struct pm_node * superclass
ClassNode::superclass.
Definition ast.h:2759
pm_class_variable_and_write_node::value
struct pm_node * value
ClassVariableAndWriteNode::value.
Definition ast.h:2847
pm_class_variable_and_write_node::name
pm_constant_id_t name
ClassVariableAndWriteNode::name.
Definition ast.h:2817
pm_class_variable_operator_write_node::name
pm_constant_id_t name
ClassVariableOperatorWriteNode::name.
Definition ast.h:2870
pm_class_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ClassVariableOperatorWriteNode::binary_operator.
Definition ast.h:2890
pm_class_variable_operator_write_node::value
struct pm_node * value
ClassVariableOperatorWriteNode::value.
Definition ast.h:2885
pm_class_variable_or_write_node::name
pm_constant_id_t name
ClassVariableOrWriteNode::name.
Definition ast.h:2913
pm_class_variable_or_write_node::value
struct pm_node * value
ClassVariableOrWriteNode::value.
Definition ast.h:2928
pm_class_variable_read_node::name
pm_constant_id_t name
ClassVariableReadNode::name.
Definition ast.h:2957
pm_class_variable_target_node::name
pm_constant_id_t name
ClassVariableTargetNode::name.
Definition ast.h:2980
pm_class_variable_write_node::value
struct pm_node * value
ClassVariableWriteNode::value.
Definition ast.h:3032
pm_class_variable_write_node::name
pm_constant_id_t name
ClassVariableWriteNode::name.
Definition ast.h:3009
pm_constant_and_write_node::name_loc
pm_location_t name_loc
ConstantAndWriteNode::name_loc.
Definition ast.h:3070
pm_constant_and_write_node::name
pm_constant_id_t name
ConstantAndWriteNode::name.
Definition ast.h:3065
pm_constant_and_write_node::value
struct pm_node * value
ConstantAndWriteNode::value.
Definition ast.h:3080
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:3103
pm_constant_operator_write_node::name_loc
pm_location_t name_loc
ConstantOperatorWriteNode::name_loc.
Definition ast.h:3108
pm_constant_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantOperatorWriteNode::binary_operator.
Definition ast.h:3123
pm_constant_operator_write_node::value
struct pm_node * value
ConstantOperatorWriteNode::value.
Definition ast.h:3118
pm_constant_or_write_node::name_loc
pm_location_t name_loc
ConstantOrWriteNode::name_loc.
Definition ast.h:3151
pm_constant_or_write_node::name
pm_constant_id_t name
ConstantOrWriteNode::name.
Definition ast.h:3146
pm_constant_or_write_node::value
struct pm_node * value
ConstantOrWriteNode::value.
Definition ast.h:3161
pm_constant_path_and_write_node::target
struct pm_constant_path_node * target
ConstantPathAndWriteNode::target.
Definition ast.h:3184
pm_constant_path_and_write_node::value
struct pm_node * value
ConstantPathAndWriteNode::value.
Definition ast.h:3194
pm_constant_path_node::name
pm_constant_id_t name
ConstantPathNode::name.
Definition ast.h:3235
pm_constant_path_node::parent
struct pm_node * parent
ConstantPathNode::parent.
Definition ast.h:3228
pm_constant_path_operator_write_node::target
struct pm_constant_path_node * target
ConstantPathOperatorWriteNode::target.
Definition ast.h:3284
pm_constant_path_operator_write_node::value
struct pm_node * value
ConstantPathOperatorWriteNode::value.
Definition ast.h:3294
pm_constant_path_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantPathOperatorWriteNode::binary_operator.
Definition ast.h:3299
pm_constant_path_or_write_node::value
struct pm_node * value
ConstantPathOrWriteNode::value.
Definition ast.h:3332
pm_constant_path_or_write_node::target
struct pm_constant_path_node * target
ConstantPathOrWriteNode::target.
Definition ast.h:3322
pm_constant_path_target_node::parent
struct pm_node * parent
ConstantPathTargetNode::parent.
Definition ast.h:3355
pm_constant_path_target_node::name
pm_constant_id_t name
ConstantPathTargetNode::name.
Definition ast.h:3360
pm_constant_path_write_node::target
struct pm_constant_path_node * target
ConstantPathWriteNode::target.
Definition ast.h:3407
pm_constant_path_write_node::value
struct pm_node * value
ConstantPathWriteNode::value.
Definition ast.h:3427
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:3444
pm_constant_read_node::name
pm_constant_id_t name
ConstantReadNode::name.
Definition ast.h:3456
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:3479
pm_constant_write_node::value
struct pm_node * value
ConstantWriteNode::value.
Definition ast.h:3531
pm_constant_write_node::name
pm_constant_id_t name
ConstantWriteNode::name.
Definition ast.h:3508
pm_def_node::parameters
struct pm_parameters_node * parameters
DefNode::parameters.
Definition ast.h:3580
pm_def_node::name
pm_constant_id_t name
DefNode::name.
Definition ast.h:3565
pm_def_node::body
struct pm_node * body
DefNode::body.
Definition ast.h:3585
pm_def_node::receiver
struct pm_node * receiver
DefNode::receiver.
Definition ast.h:3575
pm_def_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3559
pm_def_node::locals
pm_constant_id_list_t locals
DefNode::locals.
Definition ast.h:3590
pm_defined_node::value
struct pm_node * value
DefinedNode::value.
Definition ast.h:3648
pm_diagnostic_t
This struct represents a diagnostic generated during parsing.
Definition diagnostic.h:368
pm_diagnostic_t::location
pm_location_t location
The location of the diagnostic in the source.
Definition diagnostic.h:373
pm_diagnostic_t::message
const char * message
The message associated with the diagnostic.
Definition diagnostic.h:379
pm_diagnostic_t::node
pm_list_node_t node
The embedded base node.
Definition diagnostic.h:370
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:392
pm_else_node::statements
struct pm_statements_node * statements
ElseNode::statements.
Definition ast.h:3686
pm_embedded_statements_node::statements
struct pm_statements_node * statements
EmbeddedStatementsNode::statements.
Definition ast.h:3719
pm_embedded_variable_node::variable
struct pm_node * variable
EmbeddedVariableNode::variable.
Definition ast.h:3752
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:3784
pm_find_pattern_node::constant
struct pm_node * constant
FindPatternNode::constant.
Definition ast.h:3844
pm_find_pattern_node::right
struct pm_node * right
FindPatternNode::right.
Definition ast.h:3883
pm_find_pattern_node::requireds
struct pm_node_list requireds
FindPatternNode::requireds.
Definition ast.h:3870
pm_find_pattern_node::left
struct pm_splat_node * left
FindPatternNode::left.
Definition ast.h:3857
pm_flip_flop_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3929
pm_flip_flop_node::left
struct pm_node * left
FlipFlopNode::left.
Definition ast.h:3935
pm_flip_flop_node::right
struct pm_node * right
FlipFlopNode::right.
Definition ast.h:3940
pm_float_node::value
double value
FloatNode::value.
Definition ast.h:3970
pm_for_node::statements
struct pm_statements_node * statements
ForNode::statements.
Definition ast.h:4020
pm_for_node::collection
struct pm_node * collection
ForNode::collection.
Definition ast.h:4008
pm_forwarding_super_node::block
struct pm_block_node * block
ForwardingSuperNode::block.
Definition ast.h:4129
pm_global_variable_and_write_node::value
struct pm_node * value
GlobalVariableAndWriteNode::value.
Definition ast.h:4167
pm_global_variable_and_write_node::name
pm_constant_id_t name
GlobalVariableAndWriteNode::name.
Definition ast.h:4152
pm_global_variable_operator_write_node::name
pm_constant_id_t name
GlobalVariableOperatorWriteNode::name.
Definition ast.h:4190
pm_global_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
GlobalVariableOperatorWriteNode::binary_operator.
Definition ast.h:4210
pm_global_variable_operator_write_node::value
struct pm_node * value
GlobalVariableOperatorWriteNode::value.
Definition ast.h:4205
pm_global_variable_or_write_node::name
pm_constant_id_t name
GlobalVariableOrWriteNode::name.
Definition ast.h:4233
pm_global_variable_or_write_node::value
struct pm_node * value
GlobalVariableOrWriteNode::value.
Definition ast.h:4248
pm_global_variable_read_node::name
pm_constant_id_t name
GlobalVariableReadNode::name.
Definition ast.h:4277
pm_global_variable_target_node::name
pm_constant_id_t name
GlobalVariableTargetNode::name.
Definition ast.h:4300
pm_global_variable_write_node::value
struct pm_node * value
GlobalVariableWriteNode::value.
Definition ast.h:4352
pm_global_variable_write_node::name
pm_constant_id_t name
GlobalVariableWriteNode::name.
Definition ast.h:4329
pm_hash_node::elements
struct pm_node_list elements
HashNode::elements.
Definition ast.h:4403
pm_hash_pattern_node::elements
struct pm_node_list elements
HashPatternNode::elements.
Definition ast.h:4463
pm_hash_pattern_node::rest
struct pm_node * rest
HashPatternNode::rest.
Definition ast.h:4479
pm_hash_pattern_node::constant
struct pm_node * constant
HashPatternNode::constant.
Definition ast.h:4453
pm_if_node::predicate
struct pm_node * predicate
IfNode::predicate.
Definition ast.h:4559
pm_if_node::statements
struct pm_statements_node * statements
IfNode::statements.
Definition ast.h:4586
pm_imaginary_node::numeric
struct pm_node * numeric
ImaginaryNode::numeric.
Definition ast.h:4640
pm_implicit_node::value
struct pm_node * value
ImplicitNode::value.
Definition ast.h:4669
pm_in_node::statements
struct pm_statements_node * statements
InNode::statements.
Definition ast.h:4724
pm_in_node::pattern
struct pm_node * pattern
InNode::pattern.
Definition ast.h:4719
pm_index_and_write_node::arguments
struct pm_arguments_node * arguments
IndexAndWriteNode::arguments.
Definition ast.h:4778
pm_index_and_write_node::receiver
struct pm_node * receiver
IndexAndWriteNode::receiver.
Definition ast.h:4763
pm_index_and_write_node::block
struct pm_block_argument_node * block
IndexAndWriteNode::block.
Definition ast.h:4788
pm_index_and_write_node::value
struct pm_node * value
IndexAndWriteNode::value.
Definition ast.h:4798
pm_index_operator_write_node::block
struct pm_block_argument_node * block
IndexOperatorWriteNode::block.
Definition ast.h:4852
pm_index_operator_write_node::value
struct pm_node * value
IndexOperatorWriteNode::value.
Definition ast.h:4867
pm_index_operator_write_node::arguments
struct pm_arguments_node * arguments
IndexOperatorWriteNode::arguments.
Definition ast.h:4842
pm_index_operator_write_node::binary_operator
pm_constant_id_t binary_operator
IndexOperatorWriteNode::binary_operator.
Definition ast.h:4857
pm_index_operator_write_node::receiver
struct pm_node * receiver
IndexOperatorWriteNode::receiver.
Definition ast.h:4827
pm_index_or_write_node::block
struct pm_block_argument_node * block
IndexOrWriteNode::block.
Definition ast.h:4921
pm_index_or_write_node::receiver
struct pm_node * receiver
IndexOrWriteNode::receiver.
Definition ast.h:4896
pm_index_or_write_node::value
struct pm_node * value
IndexOrWriteNode::value.
Definition ast.h:4931
pm_index_or_write_node::arguments
struct pm_arguments_node * arguments
IndexOrWriteNode::arguments.
Definition ast.h:4911
pm_index_target_node::receiver
struct pm_node * receiver
IndexTargetNode::receiver.
Definition ast.h:4968
pm_index_target_node::arguments
struct pm_arguments_node * arguments
IndexTargetNode::arguments.
Definition ast.h:4978
pm_index_target_node::block
struct pm_block_argument_node * block
IndexTargetNode::block.
Definition ast.h:4988
pm_instance_variable_and_write_node::value
struct pm_node * value
InstanceVariableAndWriteNode::value.
Definition ast.h:5026
pm_instance_variable_and_write_node::name
pm_constant_id_t name
InstanceVariableAndWriteNode::name.
Definition ast.h:5011
pm_instance_variable_operator_write_node::value
struct pm_node * value
InstanceVariableOperatorWriteNode::value.
Definition ast.h:5064
pm_instance_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
InstanceVariableOperatorWriteNode::binary_operator.
Definition ast.h:5069
pm_instance_variable_operator_write_node::name
pm_constant_id_t name
InstanceVariableOperatorWriteNode::name.
Definition ast.h:5049
pm_instance_variable_or_write_node::value
struct pm_node * value
InstanceVariableOrWriteNode::value.
Definition ast.h:5107
pm_instance_variable_or_write_node::name
pm_constant_id_t name
InstanceVariableOrWriteNode::name.
Definition ast.h:5092
pm_instance_variable_read_node::name
pm_constant_id_t name
InstanceVariableReadNode::name.
Definition ast.h:5136
pm_instance_variable_target_node::name
pm_constant_id_t name
InstanceVariableTargetNode::name.
Definition ast.h:5159
pm_instance_variable_write_node::name
pm_constant_id_t name
InstanceVariableWriteNode::name.
Definition ast.h:5188
pm_instance_variable_write_node::value
struct pm_node * value
InstanceVariableWriteNode::value.
Definition ast.h:5211
pm_integer_node::value
pm_integer_t value
IntegerNode::value.
Definition ast.h:5252
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:5376
pm_interpolated_symbol_node::parts
struct pm_node_list parts
InterpolatedSymbolNode::parts.
Definition ast.h:5409
pm_interpolated_x_string_node::parts
struct pm_node_list parts
InterpolatedXStringNode::parts.
Definition ast.h:5442
pm_keyword_hash_node::elements
struct pm_node_list elements
KeywordHashNode::elements.
Definition ast.h:5509
pm_lambda_node::body
struct pm_node * body
LambdaNode::body.
Definition ast.h:5594
pm_lambda_node::opening_loc
pm_location_t opening_loc
LambdaNode::opening_loc.
Definition ast.h:5579
pm_lambda_node::parameters
struct pm_node * parameters
LambdaNode::parameters.
Definition ast.h:5589
pm_lambda_node::operator_loc
pm_location_t operator_loc
LambdaNode::operator_loc.
Definition ast.h:5574
pm_lambda_node::locals
pm_constant_id_list_t locals
LambdaNode::locals.
Definition ast.h:5569
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::tail
pm_list_node_t * tail
A pointer to the tail of the list.
Definition pm_list.h:63
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:4654
pm_local_variable_and_write_node::name
pm_constant_id_t name
LocalVariableAndWriteNode::name.
Definition ast.h:5632
pm_local_variable_and_write_node::depth
uint32_t depth
LocalVariableAndWriteNode::depth.
Definition ast.h:5637
pm_local_variable_and_write_node::value
struct pm_node * value
LocalVariableAndWriteNode::value.
Definition ast.h:5627
pm_local_variable_operator_write_node::depth
uint32_t depth
LocalVariableOperatorWriteNode::depth.
Definition ast.h:5685
pm_local_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
LocalVariableOperatorWriteNode::binary_operator.
Definition ast.h:5680
pm_local_variable_operator_write_node::value
struct pm_node * value
LocalVariableOperatorWriteNode::value.
Definition ast.h:5670
pm_local_variable_operator_write_node::name
pm_constant_id_t name
LocalVariableOperatorWriteNode::name.
Definition ast.h:5675
pm_local_variable_or_write_node::depth
uint32_t depth
LocalVariableOrWriteNode::depth.
Definition ast.h:5728
pm_local_variable_or_write_node::value
struct pm_node * value
LocalVariableOrWriteNode::value.
Definition ast.h:5718
pm_local_variable_or_write_node::name
pm_constant_id_t name
LocalVariableOrWriteNode::name.
Definition ast.h:5723
pm_local_variable_read_node::depth
uint32_t depth
LocalVariableReadNode::depth.
Definition ast.h:5774
pm_local_variable_read_node::name
pm_constant_id_t name
LocalVariableReadNode::name.
Definition ast.h:5761
pm_local_variable_target_node::depth
uint32_t depth
LocalVariableTargetNode::depth.
Definition ast.h:5805
pm_local_variable_target_node::name
pm_constant_id_t name
LocalVariableTargetNode::name.
Definition ast.h:5800
pm_local_variable_write_node::value
struct pm_node * value
LocalVariableWriteNode::value.
Definition ast.h:5874
pm_local_variable_write_node::depth
uint32_t depth
LocalVariableWriteNode::depth.
Definition ast.h:5847
pm_local_variable_write_node::name
pm_constant_id_t name
LocalVariableWriteNode::name.
Definition ast.h:5834
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:5963
pm_match_predicate_node::value
struct pm_node * value
MatchPredicateNode::value.
Definition ast.h:5958
pm_match_required_node::value
struct pm_node * value
MatchRequiredNode::value.
Definition ast.h:5996
pm_match_required_node::pattern
struct pm_node * pattern
MatchRequiredNode::pattern.
Definition ast.h:6045
pm_match_write_node::targets
struct pm_node_list targets
MatchWriteNode::targets.
Definition ast.h:6083
pm_match_write_node::call
struct pm_call_node * call
MatchWriteNode::call.
Definition ast.h:6078
pm_module_node::constant_path
struct pm_node * constant_path
ModuleNode::constant_path.
Definition ast.h:6131
pm_module_node::body
struct pm_node * body
ModuleNode::body.
Definition ast.h:6136
pm_module_node::locals
pm_constant_id_list_t locals
ModuleNode::locals.
Definition ast.h:6121
pm_module_node::name
pm_constant_id_t name
ModuleNode::name.
Definition ast.h:6146
pm_multi_target_node::lefts
struct pm_node_list lefts
MultiTargetNode::lefts.
Definition ast.h:6184
pm_multi_target_node::rest
struct pm_node * rest
MultiTargetNode::rest.
Definition ast.h:6204
pm_multi_target_node::rights
struct pm_node_list rights
MultiTargetNode::rights.
Definition ast.h:6214
pm_multi_target_state_node
This is a node in the multi target state linked list.
Definition prism_compile.c:4839
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:4865
pm_multi_write_node::value
struct pm_node * value
MultiWriteNode::value.
Definition ast.h:6337
pm_multi_write_node::rest
struct pm_node * rest
MultiWriteNode::rest.
Definition ast.h:6287
pm_multi_write_node::rights
struct pm_node_list rights
MultiWriteNode::rights.
Definition ast.h:6297
pm_multi_write_node::lefts
struct pm_node_list lefts
MultiWriteNode::lefts.
Definition ast.h:6267
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:6360
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:1057
pm_node::node_id
uint32_t node_id
The unique identifier for this node, which is deterministic based on the source.
Definition ast.h:1069
pm_node::flags
pm_node_flags_t flags
This represents any flags on the node.
Definition ast.h:1063
pm_node::location
pm_location_t location
This is the location of the node in the source.
Definition ast.h:1075
pm_numbered_reference_read_node::number
uint32_t number
NumberedReferenceReadNode::number.
Definition ast.h:6466
pm_optional_keyword_parameter_node::name
pm_constant_id_t name
OptionalKeywordParameterNode::name.
Definition ast.h:6493
pm_optional_keyword_parameter_node::value
struct pm_node * value
OptionalKeywordParameterNode::value.
Definition ast.h:6503
pm_optional_parameter_node::value
struct pm_node * value
OptionalParameterNode::value.
Definition ast.h:6545
pm_optional_parameter_node::name
pm_constant_id_t name
OptionalParameterNode::name.
Definition ast.h:6530
pm_options::version
pm_options_version_t version
The version of prism that we should be parsing with.
Definition options.h:156
pm_or_node::left
struct pm_node * left
OrNode::left.
Definition ast.h:6576
pm_or_node::right
struct pm_node * right
OrNode::right.
Definition ast.h:6589
pm_parameters_node::rest
struct pm_node * rest
ParametersNode::rest.
Definition ast.h:6633
pm_parameters_node::requireds
struct pm_node_list requireds
ParametersNode::requireds.
Definition ast.h:6623
pm_parameters_node::block
struct pm_block_parameter_node * block
ParametersNode::block.
Definition ast.h:6653
pm_parameters_node::optionals
struct pm_node_list optionals
ParametersNode::optionals.
Definition ast.h:6628
pm_parameters_node::posts
struct pm_node_list posts
ParametersNode::posts.
Definition ast.h:6638
pm_parameters_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6617
pm_parameters_node::keyword_rest
struct pm_node * keyword_rest
ParametersNode::keyword_rest.
Definition ast.h:6648
pm_parameters_node::keywords
struct pm_node_list keywords
ParametersNode::keywords.
Definition ast.h:6643
pm_parentheses_node::body
struct pm_node * body
ParenthesesNode::body.
Definition ast.h:6679
pm_parse_error_format_t
The format that will be used to format the errors into the output.
Definition prism_compile.c:10552
pm_parse_error_format_t::blank_prefix_length
size_t blank_prefix_length
The length of the blank prefix.
Definition prism_compile.c:10563
pm_parse_error_format_t::blank_prefix
const char * blank_prefix
The prefix that will be used for blank lines.
Definition prism_compile.c:10557
pm_parse_error_format_t::divider_length
size_t divider_length
The length of the divider.
Definition prism_compile.c:10566
pm_parse_error_format_t::number_prefix
const char * number_prefix
The prefix that will be used for line numbers.
Definition prism_compile.c:10554
pm_parse_error_format_t::divider
const char * divider
The divider that will be used between sections of source code.
Definition prism_compile.c:10560
pm_parse_error_t
An error that is going to be formatted into the output.
Definition prism_compile.c:10537
pm_parse_error_t::error
pm_diagnostic_t * error
A pointer to the diagnostic that was generated during parsing.
Definition prism_compile.c:10539
pm_parse_error_t::column_end
uint32_t column_end
The column end of the diagnostic message.
Definition prism_compile.c:10548
pm_parse_error_t::line
int32_t line
The start line of the diagnostic message.
Definition prism_compile.c:10542
pm_parse_error_t::column_start
uint32_t column_start
The column start of the diagnostic message.
Definition prism_compile.c:10545
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:758
pm_parser::end
const uint8_t * end
The pointer to the end of the source.
Definition parser.h:697
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:789
pm_parser::start
const uint8_t * start
The pointer to the start of the source.
Definition parser.h:694
pm_parser::error_list
pm_list_t error_list
The list of errors that have been found while parsing.
Definition parser.h:737
pm_parser::warning_list
pm_list_t warning_list
The list of warnings that have been found while parsing.
Definition parser.h:734
pm_parser::start_line
int32_t start_line
The line number at the start of the parse.
Definition parser.h:812
pm_parser::filepath
pm_string_t filepath
This is the path of the file being parsed.
Definition parser.h:783
pm_parser::newline_list
pm_newline_list_t newline_list
This is the list of newline offsets in the source file.
Definition parser.h:792
pm_pinned_variable_node::variable
struct pm_node * variable
PinnedVariableNode::variable.
Definition ast.h:6775
pm_post_execution_node::statements
struct pm_statements_node * statements
PostExecutionNode::statements.
Definition ast.h:6808
pm_pre_execution_node::statements
struct pm_statements_node * statements
PreExecutionNode::statements.
Definition ast.h:6846
pm_program_node::statements
struct pm_statements_node * statements
ProgramNode::statements.
Definition ast.h:6886
pm_range_node::right
struct pm_node * right
RangeNode::right.
Definition ast.h:6937
pm_range_node::left
struct pm_node * left
RangeNode::left.
Definition ast.h:6923
pm_rational_node::denominator
pm_integer_t denominator
RationalNode::denominator.
Definition ast.h:6986
pm_rational_node::numerator
pm_integer_t numerator
RationalNode::numerator.
Definition ast.h:6977
pm_required_parameter_node::name
pm_constant_id_t name
RequiredParameterNode::name.
Definition ast.h:7114
pm_rescue_modifier_node::rescue_expression
struct pm_node * rescue_expression
RescueModifierNode::rescue_expression.
Definition ast.h:7147
pm_rescue_modifier_node::expression
struct pm_node * expression
RescueModifierNode::expression.
Definition ast.h:7137
pm_rescue_node::subsequent
struct pm_rescue_node * subsequent
RescueNode::subsequent.
Definition ast.h:7205
pm_rescue_node::reference
struct pm_node * reference
RescueNode::reference.
Definition ast.h:7190
pm_rescue_node::exceptions
struct pm_node_list exceptions
RescueNode::exceptions.
Definition ast.h:7180
pm_rescue_node::statements
struct pm_statements_node * statements
RescueNode::statements.
Definition ast.h:7200
pm_return_node::arguments
struct pm_arguments_node * arguments
ReturnNode::arguments.
Definition ast.h:7288
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:7337
pm_shareable_constant_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7329
pm_singleton_class_node::locals
pm_constant_id_list_t locals
SingletonClassNode::locals.
Definition ast.h:7360
pm_singleton_class_node::expression
struct pm_node * expression
SingletonClassNode::expression.
Definition ast.h:7375
pm_singleton_class_node::body
struct pm_node * body
SingletonClassNode::body.
Definition ast.h:7380
pm_source_file_node::filepath
pm_string_t filepath
SourceFileNode::filepath.
Definition ast.h:7434
pm_splat_node::expression
struct pm_node * expression
SplatNode::expression.
Definition ast.h:7480
pm_statements_node::body
struct pm_node_list body
StatementsNode::body.
Definition ast.h:7503
pm_statements_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7497
pm_string_node::unescaped
pm_string_t unescaped
StringNode::unescaped.
Definition ast.h:7553
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:7593
pm_super_node::block
struct pm_node * block
SuperNode::block.
Definition ast.h:7603
pm_symbol_node::unescaped
pm_string_t unescaped
SymbolNode::unescaped.
Definition ast.h:7649
pm_symbol_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7628
pm_undef_node::names
struct pm_node_list names
UndefNode::names.
Definition ast.h:7690
pm_unless_node::statements
struct pm_statements_node * statements
UnlessNode::statements.
Definition ast.h:7763
pm_unless_node::predicate
struct pm_node * predicate
UnlessNode::predicate.
Definition ast.h:7742
pm_unless_node::else_clause
struct pm_else_node * else_clause
UnlessNode::else_clause.
Definition ast.h:7773
pm_until_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7806
pm_while_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7895
pm_x_string_node::unescaped
pm_string_t unescaped
XStringNode::unescaped.
Definition ast.h:7963
pm_yield_node::arguments
struct pm_arguments_node * arguments
YieldNode::arguments.
Definition ast.h:7996
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:405
rb_iseq_new_with_callback_callback_func
Definition vm_core.h:1252
rb_stdin_wrapper
Definition prism_compile.c:11473
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