Ruby: prism_compile.c Source File

Ruby 3.4.3p32 (2025-04-14 revision d0b7e5b6a04bde21ca483d20a1546b28b401c2d4)

prism_compile.c
1#include "prism.h"
2
8 typedef struct {
10 int32_t line;
11
13 uint32_t node_id;
14} pm_node_location_t;
15
16/******************************************************************************/
17/* These macros operate on pm_node_location_t structs as opposed to NODE*s. */
18/******************************************************************************/
19
20#define PUSH_ADJUST(seq, location, label) \
21 ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), (int) (location).line))
22
23#define PUSH_ADJUST_RESTORE(seq, label) \
24 ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), -1))
25
26#define PUSH_INSN(seq, location, insn) \
27 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 0))
28
29#define PUSH_INSN1(seq, location, insn, op1) \
30 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 1, (VALUE)(op1)))
31
32#define PUSH_INSN2(seq, location, insn, op1, op2) \
33 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 2, (VALUE)(op1), (VALUE)(op2)))
34
35#define PUSH_INSN3(seq, location, insn, op1, op2, op3) \
36 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)))
37
38#define PUSH_INSNL(seq, location, insn, label) \
39 (PUSH_INSN1(seq, location, insn, label), LABEL_REF(label))
40
41#define PUSH_LABEL(seq, label) \
42 ADD_ELEM((seq), (LINK_ELEMENT *) (label))
43
44#define PUSH_SEND_R(seq, location, id, argc, block, flag, keywords) \
45 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_send(iseq, (int) (location).line, (int) (location).node_id, (id), (VALUE)(argc), (block), (VALUE)(flag), (keywords)))
46
47#define PUSH_SEND(seq, location, id, argc) \
48 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)INT2FIX(0), NULL)
49
50#define PUSH_SEND_WITH_FLAG(seq, location, id, argc, flag) \
51 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)(flag), NULL)
52
53#define PUSH_SEND_WITH_BLOCK(seq, location, id, argc, block) \
54 PUSH_SEND_R((seq), location, (id), (argc), (block), (VALUE)INT2FIX(0), NULL)
55
56#define PUSH_CALL(seq, location, id, argc) \
57 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)INT2FIX(VM_CALL_FCALL), NULL)
58
59#define PUSH_CALL_WITH_BLOCK(seq, location, id, argc, block) \
60 PUSH_SEND_R((seq), location, (id), (argc), (block), (VALUE)INT2FIX(VM_CALL_FCALL), NULL)
61
62#define PUSH_TRACE(seq, event) \
63 ADD_ELEM((seq), (LINK_ELEMENT *) new_trace_body(iseq, (event), 0))
64
65#define PUSH_CATCH_ENTRY(type, ls, le, iseqv, lc) \
66 ADD_CATCH_ENTRY((type), (ls), (le), (iseqv), (lc))
67
68#define PUSH_SEQ(seq1, seq2) \
69 APPEND_LIST((seq1), (seq2))
70
71#define PUSH_SYNTHETIC_PUTNIL(seq, iseq) \
72 do { \
73 int lineno = ISEQ_COMPILE_DATA(iseq)->last_line; \
74 if (lineno == 0) lineno = FIX2INT(rb_iseq_first_lineno(iseq)); \
75 ADD_SYNTHETIC_INSN(seq, lineno, -1, putnil); \
76 } while (0)
77
78/******************************************************************************/
79/* These functions compile getlocal/setlocal instructions but operate on */
80/* prism locations instead of NODEs. */
81/******************************************************************************/
82
83static void
84pm_iseq_add_getlocal(rb_iseq_t *iseq, LINK_ANCHOR *const seq, int line, int node_id, int idx, int level)
85{
86 if (iseq_local_block_param_p(iseq, idx, level)) {
87 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(getblockparam), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
88 }
89 else {
90 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(getlocal), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
91 }
92 if (level > 0) access_outer_variables(iseq, level, iseq_lvar_id(iseq, idx, level), Qfalse);
93}
94
95static void
96pm_iseq_add_setlocal(rb_iseq_t *iseq, LINK_ANCHOR *const seq, int line, int node_id, int idx, int level)
97{
98 if (iseq_local_block_param_p(iseq, idx, level)) {
99 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(setblockparam), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
100 }
101 else {
102 ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(setlocal), 2, INT2FIX((idx) + VM_ENV_DATA_SIZE - 1), INT2FIX(level)));
103 }
104 if (level > 0) access_outer_variables(iseq, level, iseq_lvar_id(iseq, idx, level), Qtrue);
105}
106
107#define PUSH_GETLOCAL(seq, location, idx, level) \
108 pm_iseq_add_getlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
109
110#define PUSH_SETLOCAL(seq, location, idx, level) \
111 pm_iseq_add_setlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
112
113/******************************************************************************/
114/* These are helper macros for the compiler. */
115/******************************************************************************/
116
117#define OLD_ISEQ NEW_ISEQ
118#undef NEW_ISEQ
119
120#define NEW_ISEQ(node, name, type, line_no) \
121 pm_new_child_iseq(iseq, (node), rb_fstring(name), 0, (type), (line_no))
122
123#define OLD_CHILD_ISEQ NEW_CHILD_ISEQ
124#undef NEW_CHILD_ISEQ
125
126#define NEW_CHILD_ISEQ(node, name, type, line_no) \
127 pm_new_child_iseq(iseq, (node), rb_fstring(name), iseq, (type), (line_no))
128
129#define PM_COMPILE(node) \
130 pm_compile_node(iseq, (node), ret, popped, scope_node)
131
132#define PM_COMPILE_INTO_ANCHOR(_ret, node) \
133 pm_compile_node(iseq, (node), _ret, popped, scope_node)
134
135#define PM_COMPILE_POPPED(node) \
136 pm_compile_node(iseq, (node), ret, true, scope_node)
137
138#define PM_COMPILE_NOT_POPPED(node) \
139 pm_compile_node(iseq, (node), ret, false, scope_node)
140
141#define PM_NODE_START_LOCATION(parser, node) \
142 ((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 })
143
144#define PM_NODE_END_LOCATION(parser, node) \
145 ((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 })
146
147#define PM_LOCATION_START_LOCATION(parser, location, id) \
148 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, (location)->start, (parser)->start_line), .node_id = id })
149
150#define PM_NODE_START_LINE_COLUMN(parser, node) \
151 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.start, (parser)->start_line)
152
153#define PM_NODE_END_LINE_COLUMN(parser, node) \
154 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.end, (parser)->start_line)
155
156#define PM_LOCATION_START_LINE_COLUMN(parser, location) \
157 pm_newline_list_line_column(&(parser)->newline_list, (location)->start, (parser)->start_line)
158
159static int
160pm_node_line_number(const pm_parser_t *parser, const pm_node_t *node)
161{
162 return (int) pm_newline_list_line(&parser->newline_list, node->location.start, parser->start_line);
163}
164
165static int
166pm_location_line_number(const pm_parser_t *parser, const pm_location_t *location) {
167 return (int) pm_newline_list_line(&parser->newline_list, location->start, parser->start_line);
168}
169
173static VALUE
174parse_integer_value(const pm_integer_t *integer)
175{
176 VALUE result;
177
178 if (integer->values == NULL) {
179 result = UINT2NUM(integer->value);
180 }
181 else {
182 VALUE string = rb_str_new(NULL, integer->length * 8);
183 unsigned char *bytes = (unsigned char *) RSTRING_PTR(string);
184
185 size_t offset = integer->length * 8;
186 for (size_t value_index = 0; value_index < integer->length; value_index++) {
187 uint32_t value = integer->values[value_index];
188
189 for (int index = 0; index < 8; index++) {
190 int byte = (value >> (4 * index)) & 0xf;
191 bytes[--offset] = byte < 10 ? byte + '0' : byte - 10 + 'a';
192 }
193 }
194
195 result = rb_funcall(string, rb_intern("to_i"), 1, UINT2NUM(16));
196 }
197
198 if (integer->negative) {
199 result = rb_funcall(result, rb_intern("-@"), 0);
200 }
201
202 return result;
203}
204
208static inline VALUE
209parse_integer(const pm_integer_node_t *node)
210{
211 return parse_integer_value(&node->value);
212}
213
217static VALUE
218parse_float(const pm_float_node_t *node)
219{
220 return DBL2NUM(node->value);
221}
222
229static VALUE
230parse_rational(const pm_rational_node_t *node)
231{
232 VALUE numerator = parse_integer_value(&node->numerator);
233 VALUE denominator = parse_integer_value(&node->denominator);
234 return rb_rational_new(numerator, denominator);
235}
236
243static VALUE
244parse_imaginary(const pm_imaginary_node_t *node)
245{
246 VALUE imaginary_part;
247 switch (PM_NODE_TYPE(node->numeric)) {
248 case PM_FLOAT_NODE: {
249 imaginary_part = parse_float((const pm_float_node_t *) node->numeric);
250 break;
251 }
252 case PM_INTEGER_NODE: {
253 imaginary_part = parse_integer((const pm_integer_node_t *) node->numeric);
254 break;
255 }
256 case PM_RATIONAL_NODE: {
257 imaginary_part = parse_rational((const pm_rational_node_t *) node->numeric);
258 break;
259 }
260 default:
261 rb_bug("Unexpected numeric type on imaginary number %s\n", pm_node_type_to_str(PM_NODE_TYPE(node->numeric)));
262 }
263
264 return rb_complex_raw(INT2FIX(0), imaginary_part);
265}
266
267static inline VALUE
268parse_string(const pm_scope_node_t *scope_node, const pm_string_t *string)
269{
270 return rb_enc_str_new((const char *) pm_string_source(string), pm_string_length(string), scope_node->encoding);
271}
272
278static inline VALUE
279parse_string_encoded(const pm_node_t *node, const pm_string_t *string, rb_encoding *default_encoding)
280{
281 rb_encoding *encoding;
282
283 if (node->flags & PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING) {
284 encoding = rb_ascii8bit_encoding();
285 }
286 else if (node->flags & PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING) {
287 encoding = rb_utf8_encoding();
288 }
289 else {
290 encoding = default_encoding;
291 }
292
293 return rb_enc_str_new((const char *) pm_string_source(string), pm_string_length(string), encoding);
294}
295
296static inline VALUE
297parse_static_literal_string(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_string_t *string)
298{
299 rb_encoding *encoding;
300
301 if (node->flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
302 encoding = rb_ascii8bit_encoding();
303 }
304 else if (node->flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
305 encoding = rb_utf8_encoding();
306 }
307 else {
308 encoding = scope_node->encoding;
309 }
310
311 VALUE value = rb_enc_literal_str((const char *) pm_string_source(string), pm_string_length(string), encoding);
312 rb_enc_str_coderange(value);
313
314 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
315 int line_number = pm_node_line_number(scope_node->parser, node);
316 value = rb_str_with_debug_created_info(value, rb_iseq_path(iseq), line_number);
317 }
318
319 return value;
320}
321
322static inline ID
323parse_string_symbol(const pm_scope_node_t *scope_node, const pm_symbol_node_t *symbol)
324{
325 rb_encoding *encoding;
326 if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING) {
327 encoding = rb_utf8_encoding();
328 }
329 else if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING) {
330 encoding = rb_ascii8bit_encoding();
331 }
332 else if (symbol->base.flags & PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING) {
333 encoding = rb_usascii_encoding();
334 }
335 else {
336 encoding = scope_node->encoding;
337 }
338
339 return rb_intern3((const char *) pm_string_source(&symbol->unescaped), pm_string_length(&symbol->unescaped), encoding);
340}
341
342static int
343pm_optimizable_range_item_p(const pm_node_t *node)
344{
345 return (!node || PM_NODE_TYPE_P(node, PM_INTEGER_NODE) || PM_NODE_TYPE_P(node, PM_NIL_NODE));
346}
347
349static VALUE
350parse_regexp_error(rb_iseq_t *iseq, int32_t line_number, const char *fmt, ...)
351{
352 va_list args;
353 va_start(args, fmt);
354 VALUE error = rb_syntax_error_append(Qnil, rb_iseq_path(iseq), line_number, -1, NULL, "%" PRIsVALUE, args);
355 va_end(args);
356 rb_exc_raise(error);
357}
358
359static VALUE
360parse_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)
361{
362 // If we were passed an explicit regexp encoding, then we need to double
363 // check that it's okay here for this fragment of the string.
364 rb_encoding *encoding;
365
366 if (explicit_regexp_encoding != NULL) {
367 encoding = explicit_regexp_encoding;
368 }
369 else if (node->flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
370 encoding = rb_ascii8bit_encoding();
371 }
372 else if (node->flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
373 encoding = rb_utf8_encoding();
374 }
375 else {
376 encoding = implicit_regexp_encoding;
377 }
378
379 VALUE string = rb_enc_str_new((const char *) pm_string_source(unescaped), pm_string_length(unescaped), encoding);
380 VALUE error = rb_reg_check_preprocess(string);
381
382 if (error != Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, node), "%" PRIsVALUE, rb_obj_as_string(error));
383 return string;
384}
385
386static VALUE
387pm_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)
388{
389 VALUE current = Qnil;
390
391 for (size_t index = 0; index < nodes->size; index++) {
392 const pm_node_t *part = nodes->nodes[index];
393 VALUE string;
394
395 switch (PM_NODE_TYPE(part)) {
396 case PM_STRING_NODE:
397 if (implicit_regexp_encoding != NULL) {
398 if (top) {
399 string = parse_regexp_string_part(iseq, scope_node, part, &((const pm_string_node_t *) part)->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
400 }
401 else {
402 string = parse_string_encoded(part, &((const pm_string_node_t *) part)->unescaped, scope_node->encoding);
403 VALUE error = rb_reg_check_preprocess(string);
404 if (error != Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, part), "%" PRIsVALUE, rb_obj_as_string(error));
405 }
406 }
407 else {
408 string = parse_string_encoded(part, &((const pm_string_node_t *) part)->unescaped, scope_node->encoding);
409 }
410 break;
411 case PM_INTERPOLATED_STRING_NODE:
412 string = pm_static_literal_concat(iseq, &((const pm_interpolated_string_node_t *) part)->parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
413 break;
414 case PM_EMBEDDED_STATEMENTS_NODE: {
415 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) part;
416 string = pm_static_literal_concat(iseq, &cast->statements->body, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
417 break;
418 }
419 default:
420 RUBY_ASSERT(false && "unexpected node type in pm_static_literal_concat");
421 return Qnil;
422 }
423
424 if (current != Qnil) {
425 current = rb_str_concat(current, string);
426 }
427 else {
428 current = string;
429 }
430 }
431
432 return top ? rb_fstring(current) : current;
433}
434
435#define RE_OPTION_ENCODING_SHIFT 8
436#define RE_OPTION_ENCODING(encoding) (((encoding) & 0xFF) << RE_OPTION_ENCODING_SHIFT)
437#define ARG_ENCODING_NONE 32
438#define ARG_ENCODING_FIXED 16
439#define ENC_ASCII8BIT 1
440#define ENC_EUC_JP 2
441#define ENC_Windows_31J 3
442#define ENC_UTF8 4
443
448static int
449parse_regexp_flags(const pm_node_t *node)
450{
451 int flags = 0;
452
453 // Check "no encoding" first so that flags don't get clobbered
454 // We're calling `rb_char_to_option_kcode` in this case so that
455 // we don't need to have access to `ARG_ENCODING_NONE`
456 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
457 flags |= ARG_ENCODING_NONE;
458 }
459
460 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
461 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_EUC_JP));
462 }
463
464 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
465 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_Windows_31J));
466 }
467
468 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
469 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_UTF8));
470 }
471
472 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
473 flags |= ONIG_OPTION_IGNORECASE;
474 }
475
476 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
477 flags |= ONIG_OPTION_MULTILINE;
478 }
479
480 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
481 flags |= ONIG_OPTION_EXTEND;
482 }
483
484 return flags;
485}
486
487#undef RE_OPTION_ENCODING_SHIFT
488#undef RE_OPTION_ENCODING
489#undef ARG_ENCODING_FIXED
490#undef ARG_ENCODING_NONE
491#undef ENC_ASCII8BIT
492#undef ENC_EUC_JP
493#undef ENC_Windows_31J
494#undef ENC_UTF8
495
496static rb_encoding *
497parse_regexp_encoding(const pm_scope_node_t *scope_node, const pm_node_t *node)
498{
499 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) || PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
500 return rb_ascii8bit_encoding();
501 }
502 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
503 return rb_utf8_encoding();
504 }
505 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
506 return rb_enc_get_from_index(ENCINDEX_EUC_JP);
507 }
508 else if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
509 return rb_enc_get_from_index(ENCINDEX_Windows_31J);
510 }
511 else {
512 return NULL;
513 }
514}
515
516static VALUE
517parse_regexp(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, VALUE string)
518{
519 VALUE errinfo = rb_errinfo();
520
521 int32_t line_number = pm_node_line_number(scope_node->parser, node);
522 VALUE regexp = rb_reg_compile(string, parse_regexp_flags(node), (const char *) pm_string_source(&scope_node->parser->filepath), line_number);
523
524 if (NIL_P(regexp)) {
525 VALUE message = rb_attr_get(rb_errinfo(), idMesg);
526 rb_set_errinfo(errinfo);
527
528 parse_regexp_error(iseq, line_number, "%" PRIsVALUE, message);
529 return Qnil;
530 }
531
532 rb_obj_freeze(regexp);
533 return regexp;
534}
535
536static inline VALUE
537parse_regexp_literal(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_string_t *unescaped)
538{
539 rb_encoding *regexp_encoding = parse_regexp_encoding(scope_node, node);
540 if (regexp_encoding == NULL) regexp_encoding = scope_node->encoding;
541
542 VALUE string = rb_enc_str_new((const char *) pm_string_source(unescaped), pm_string_length(unescaped), regexp_encoding);
543 return parse_regexp(iseq, scope_node, node, string);
544}
545
546static inline VALUE
547parse_regexp_concat(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, const pm_node_t *node, const pm_node_list_t *parts)
548{
549 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
550 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
551
552 VALUE string = pm_static_literal_concat(iseq, parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding, false);
553 return parse_regexp(iseq, scope_node, node, string);
554}
555
556static 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);
557
558static int
559pm_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)
560{
561 int stack_size = 0;
562 size_t parts_size = parts->size;
563 bool interpolated = false;
564
565 if (parts_size > 0) {
566 VALUE current_string = Qnil;
567 pm_node_location_t current_location = *node_location;
568
569 for (size_t index = 0; index < parts_size; index++) {
570 const pm_node_t *part = parts->nodes[index];
571
572 if (PM_NODE_TYPE_P(part, PM_STRING_NODE)) {
573 const pm_string_node_t *string_node = (const pm_string_node_t *) part;
574 VALUE string_value;
575
576 if (implicit_regexp_encoding == NULL) {
577 string_value = parse_string_encoded(part, &string_node->unescaped, scope_node->encoding);
578 }
579 else {
580 string_value = parse_regexp_string_part(iseq, scope_node, (const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
581 }
582
583 if (RTEST(current_string)) {
584 current_string = rb_str_concat(current_string, string_value);
585 }
586 else {
587 current_string = string_value;
588 if (index != 0) current_location = PM_NODE_END_LOCATION(scope_node->parser, part);
589 }
590 }
591 else {
592 interpolated = true;
593
594 if (
595 PM_NODE_TYPE_P(part, PM_EMBEDDED_STATEMENTS_NODE) &&
596 ((const pm_embedded_statements_node_t *) part)->statements != NULL &&
597 ((const pm_embedded_statements_node_t *) part)->statements->body.size == 1 &&
598 PM_NODE_TYPE_P(((const pm_embedded_statements_node_t *) part)->statements->body.nodes[0], PM_STRING_NODE)
599 ) {
600 const pm_string_node_t *string_node = (const pm_string_node_t *) ((const pm_embedded_statements_node_t *) part)->statements->body.nodes[0];
601 VALUE string_value;
602
603 if (implicit_regexp_encoding == NULL) {
604 string_value = parse_string_encoded(part, &string_node->unescaped, scope_node->encoding);
605 }
606 else {
607 string_value = parse_regexp_string_part(iseq, scope_node, (const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
608 }
609
610 if (RTEST(current_string)) {
611 current_string = rb_str_concat(current_string, string_value);
612 }
613 else {
614 current_string = string_value;
615 current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
616 }
617 }
618 else {
619 if (!RTEST(current_string)) {
620 rb_encoding *encoding;
621
622 if (implicit_regexp_encoding != NULL) {
623 if (explicit_regexp_encoding != NULL) {
624 encoding = explicit_regexp_encoding;
625 }
626 else if (scope_node->parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
627 encoding = rb_ascii8bit_encoding();
628 }
629 else {
630 encoding = implicit_regexp_encoding;
631 }
632 }
633 else {
634 encoding = scope_node->encoding;
635 }
636
637 if (parts_size == 1) {
638 current_string = rb_enc_str_new(NULL, 0, encoding);
639 }
640 }
641
642 if (RTEST(current_string)) {
643 VALUE operand = rb_fstring(current_string);
644 PUSH_INSN1(ret, current_location, putobject, operand);
645 stack_size++;
646 }
647
648 PM_COMPILE_NOT_POPPED(part);
649
650 const pm_node_location_t current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
651 PUSH_INSN(ret, current_location, dup);
652
653 {
654 const struct rb_callinfo *callinfo = new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE, NULL, FALSE);
655 PUSH_INSN1(ret, current_location, objtostring, callinfo);
656 }
657
658 PUSH_INSN(ret, current_location, anytostring);
659
660 current_string = Qnil;
661 stack_size++;
662 }
663 }
664 }
665
666 if (RTEST(current_string)) {
667 current_string = rb_fstring(current_string);
668
669 if (stack_size == 0 && interpolated) {
670 PUSH_INSN1(ret, current_location, putstring, current_string);
671 }
672 else {
673 PUSH_INSN1(ret, current_location, putobject, current_string);
674 }
675
676 current_string = Qnil;
677 stack_size++;
678 }
679 }
680 else {
681 PUSH_INSN(ret, *node_location, putnil);
682 }
683
684 return stack_size;
685}
686
687static void
688pm_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)
689{
690 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
691 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
692
693 int length = pm_interpolated_node_compile(iseq, parts, node_location, ret, popped, scope_node, implicit_regexp_encoding, explicit_regexp_encoding);
694 PUSH_INSN2(ret, *node_location, toregexp, INT2FIX(parse_regexp_flags(node) & 0xFF), INT2FIX(length));
695}
696
697static VALUE
698pm_source_file_value(const pm_source_file_node_t *node, const pm_scope_node_t *scope_node)
699{
700 const pm_string_t *filepath = &node->filepath;
701 size_t length = pm_string_length(filepath);
702
703 if (length > 0) {
704 rb_encoding *filepath_encoding = scope_node->filepath_encoding != NULL ? scope_node->filepath_encoding : rb_utf8_encoding();
705 return rb_enc_interned_str((const char *) pm_string_source(filepath), length, filepath_encoding);
706 }
707 else {
708 return rb_fstring_lit("<compiled>");
709 }
710}
711
716static VALUE
717pm_static_literal_string(rb_iseq_t *iseq, VALUE string, int line_number)
718{
719 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
720 return rb_str_with_debug_created_info(string, rb_iseq_path(iseq), line_number);
721 }
722 else {
723 return rb_fstring(string);
724 }
725}
726
732static VALUE
733pm_static_literal_value(rb_iseq_t *iseq, const pm_node_t *node, const pm_scope_node_t *scope_node)
734{
735 // Every node that comes into this function should already be marked as
736 // static literal. If it's not, then we have a bug somewhere.
737 RUBY_ASSERT(PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL));
738
739 switch (PM_NODE_TYPE(node)) {
740 case PM_ARRAY_NODE: {
741 const pm_array_node_t *cast = (const pm_array_node_t *) node;
742 const pm_node_list_t *elements = &cast->elements;
743
744 VALUE value = rb_ary_hidden_new(elements->size);
745 for (size_t index = 0; index < elements->size; index++) {
746 rb_ary_push(value, pm_static_literal_value(iseq, elements->nodes[index], scope_node));
747 }
748
749 OBJ_FREEZE(value);
750 return value;
751 }
752 case PM_FALSE_NODE:
753 return Qfalse;
754 case PM_FLOAT_NODE:
755 return parse_float((const pm_float_node_t *) node);
756 case PM_HASH_NODE: {
757 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
758 const pm_node_list_t *elements = &cast->elements;
759
760 VALUE array = rb_ary_hidden_new(elements->size * 2);
761 for (size_t index = 0; index < elements->size; index++) {
762 RUBY_ASSERT(PM_NODE_TYPE_P(elements->nodes[index], PM_ASSOC_NODE));
763 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) elements->nodes[index];
764 VALUE pair[2] = { pm_static_literal_value(iseq, cast->key, scope_node), pm_static_literal_value(iseq, cast->value, scope_node) };
765 rb_ary_cat(array, pair, 2);
766 }
767
768 VALUE value = rb_hash_new_with_size(elements->size);
769 rb_hash_bulk_insert(RARRAY_LEN(array), RARRAY_CONST_PTR(array), value);
770
771 value = rb_obj_hide(value);
772 OBJ_FREEZE(value);
773 return value;
774 }
775 case PM_IMAGINARY_NODE:
776 return parse_imaginary((const pm_imaginary_node_t *) node);
777 case PM_INTEGER_NODE:
778 return parse_integer((const pm_integer_node_t *) node);
779 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
780 const pm_interpolated_match_last_line_node_t *cast = (const pm_interpolated_match_last_line_node_t *) node;
781 return parse_regexp_concat(iseq, scope_node, (const pm_node_t *) cast, &cast->parts);
782 }
783 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
784 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
785 return parse_regexp_concat(iseq, scope_node, (const pm_node_t *) cast, &cast->parts);
786 }
787 case PM_INTERPOLATED_STRING_NODE: {
788 VALUE string = pm_static_literal_concat(iseq, &((const pm_interpolated_string_node_t *) node)->parts, scope_node, NULL, NULL, false);
789 int line_number = pm_node_line_number(scope_node->parser, node);
790 return pm_static_literal_string(iseq, string, line_number);
791 }
792 case PM_INTERPOLATED_SYMBOL_NODE: {
793 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
794 VALUE string = pm_static_literal_concat(iseq, &cast->parts, scope_node, NULL, NULL, true);
795
796 return ID2SYM(rb_intern_str(string));
797 }
798 case PM_MATCH_LAST_LINE_NODE: {
799 const pm_match_last_line_node_t *cast = (const pm_match_last_line_node_t *) node;
800 return parse_regexp_literal(iseq, scope_node, (const pm_node_t *) cast, &cast->unescaped);
801 }
802 case PM_NIL_NODE:
803 return Qnil;
804 case PM_RATIONAL_NODE:
805 return parse_rational((const pm_rational_node_t *) node);
806 case PM_REGULAR_EXPRESSION_NODE: {
807 const pm_regular_expression_node_t *cast = (const pm_regular_expression_node_t *) node;
808 return parse_regexp_literal(iseq, scope_node, (const pm_node_t *) cast, &cast->unescaped);
809 }
810 case PM_SOURCE_ENCODING_NODE:
811 return rb_enc_from_encoding(scope_node->encoding);
812 case PM_SOURCE_FILE_NODE: {
813 const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
814 return pm_source_file_value(cast, scope_node);
815 }
816 case PM_SOURCE_LINE_NODE:
817 return INT2FIX(pm_node_line_number(scope_node->parser, node));
818 case PM_STRING_NODE: {
819 const pm_string_node_t *cast = (const pm_string_node_t *) node;
820 return parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
821 }
822 case PM_SYMBOL_NODE:
823 return ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) node));
824 case PM_TRUE_NODE:
825 return Qtrue;
826 default:
827 rb_bug("Don't have a literal value for node type %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
828 return Qfalse;
829 }
830}
831
835static rb_code_location_t
836pm_code_location(const pm_scope_node_t *scope_node, const pm_node_t *node)
837{
838 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, node);
839 const pm_line_column_t end_location = PM_NODE_END_LINE_COLUMN(scope_node->parser, node);
840
841 return (rb_code_location_t) {
842 .beg_pos = { .lineno = start_location.line, .column = start_location.column },
843 .end_pos = { .lineno = end_location.line, .column = end_location.column }
844 };
845}
846
852#define PM_BRANCH_COVERAGE_P(iseq) (ISEQ_COVERAGE(iseq) && ISEQ_BRANCH_COVERAGE(iseq))
853
854static void
855pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond,
856 LABEL *then_label, LABEL *else_label, bool popped, pm_scope_node_t *scope_node);
857
858static void
859pm_compile_logical(rb_iseq_t *iseq, LINK_ANCHOR *const ret, pm_node_t *cond, LABEL *then_label, LABEL *else_label, bool popped, pm_scope_node_t *scope_node)
860{
861 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, cond);
862
863 DECL_ANCHOR(seq);
864
865 LABEL *label = NEW_LABEL(location.line);
866 if (!then_label) then_label = label;
867 else if (!else_label) else_label = label;
868
869 pm_compile_branch_condition(iseq, seq, cond, then_label, else_label, popped, scope_node);
870
871 if (LIST_INSN_SIZE_ONE(seq)) {
872 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(seq));
873 if (insn->insn_id == BIN(jump) && (LABEL *)(insn->operands[0]) == label) return;
874 }
875
876 if (!label->refcnt) {
877 if (popped) PUSH_INSN(ret, location, putnil);
878 }
879 else {
880 PUSH_LABEL(seq, label);
881 }
882
883 PUSH_SEQ(ret, seq);
884 return;
885}
886
887static void
888pm_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)
889{
890 const pm_node_location_t location = { .line = ISEQ_BODY(iseq)->location.first_lineno, .node_id = -1 };
891
892 if (PM_NODE_TYPE_P(node, PM_INTEGER_NODE)) {
893 PM_COMPILE_NOT_POPPED(node);
894
895 VALUE operand = ID2SYM(rb_intern("$."));
896 PUSH_INSN1(ret, location, getglobal, operand);
897
898 PUSH_SEND(ret, location, idEq, INT2FIX(1));
899 if (popped) PUSH_INSN(ret, location, pop);
900 }
901 else {
902 PM_COMPILE(node);
903 }
904}
905
906static void
907pm_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)
908{
909 const pm_node_location_t location = { .line = ISEQ_BODY(iseq)->location.first_lineno, .node_id = -1 };
910 LABEL *lend = NEW_LABEL(location.line);
911
912 int again = !(flip_flop_node->base.flags & PM_RANGE_FLAGS_EXCLUDE_END);
913
914 rb_num_t count = ISEQ_FLIP_CNT_INCREMENT(ISEQ_BODY(iseq)->local_iseq) + VM_SVAR_FLIPFLOP_START;
915 VALUE key = INT2FIX(count);
916
917 PUSH_INSN2(ret, location, getspecial, key, INT2FIX(0));
918 PUSH_INSNL(ret, location, branchif, lend);
919
920 if (flip_flop_node->left) {
921 pm_compile_flip_flop_bound(iseq, flip_flop_node->left, ret, popped, scope_node);
922 }
923 else {
924 PUSH_INSN(ret, location, putnil);
925 }
926
927 PUSH_INSNL(ret, location, branchunless, else_label);
928 PUSH_INSN1(ret, location, putobject, Qtrue);
929 PUSH_INSN1(ret, location, setspecial, key);
930 if (!again) {
931 PUSH_INSNL(ret, location, jump, then_label);
932 }
933
934 PUSH_LABEL(ret, lend);
935 if (flip_flop_node->right) {
936 pm_compile_flip_flop_bound(iseq, flip_flop_node->right, ret, popped, scope_node);
937 }
938 else {
939 PUSH_INSN(ret, location, putnil);
940 }
941
942 PUSH_INSNL(ret, location, branchunless, then_label);
943 PUSH_INSN1(ret, location, putobject, Qfalse);
944 PUSH_INSN1(ret, location, setspecial, key);
945 PUSH_INSNL(ret, location, jump, then_label);
946}
947
948static 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);
949
950static void
951pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const pm_node_t *cond, LABEL *then_label, LABEL *else_label, bool popped, pm_scope_node_t *scope_node)
952{
953 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, cond);
954
955again:
956 switch (PM_NODE_TYPE(cond)) {
957 case PM_AND_NODE: {
958 const pm_and_node_t *cast = (const pm_and_node_t *) cond;
959 pm_compile_logical(iseq, ret, cast->left, NULL, else_label, popped, scope_node);
960
961 cond = cast->right;
962 goto again;
963 }
964 case PM_OR_NODE: {
965 const pm_or_node_t *cast = (const pm_or_node_t *) cond;
966 pm_compile_logical(iseq, ret, cast->left, then_label, NULL, popped, scope_node);
967
968 cond = cast->right;
969 goto again;
970 }
971 case PM_FALSE_NODE:
972 case PM_NIL_NODE:
973 PUSH_INSNL(ret, location, jump, else_label);
974 return;
975 case PM_FLOAT_NODE:
976 case PM_IMAGINARY_NODE:
977 case PM_INTEGER_NODE:
978 case PM_LAMBDA_NODE:
979 case PM_RATIONAL_NODE:
980 case PM_REGULAR_EXPRESSION_NODE:
981 case PM_STRING_NODE:
982 case PM_SYMBOL_NODE:
983 case PM_TRUE_NODE:
984 PUSH_INSNL(ret, location, jump, then_label);
985 return;
986 case PM_FLIP_FLOP_NODE:
987 pm_compile_flip_flop((const pm_flip_flop_node_t *) cond, else_label, then_label, iseq, location.line, ret, popped, scope_node);
988 return;
989 case PM_DEFINED_NODE: {
990 const pm_defined_node_t *cast = (const pm_defined_node_t *) cond;
991 pm_compile_defined_expr(iseq, cast->value, &location, ret, popped, scope_node, true);
992 break;
993 }
994 default: {
995 DECL_ANCHOR(cond_seq);
996 pm_compile_node(iseq, cond, cond_seq, false, scope_node);
997
998 if (LIST_INSN_SIZE_ONE(cond_seq)) {
999 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(cond_seq));
1000
1001 if (insn->insn_id == BIN(putobject)) {
1002 if (RTEST(insn->operands[0])) {
1003 PUSH_INSNL(ret, location, jump, then_label);
1004 // maybe unreachable
1005 return;
1006 }
1007 else {
1008 PUSH_INSNL(ret, location, jump, else_label);
1009 return;
1010 }
1011 }
1012 }
1013
1014 PUSH_SEQ(ret, cond_seq);
1015 break;
1016 }
1017 }
1018
1019 PUSH_INSNL(ret, location, branchunless, else_label);
1020 PUSH_INSNL(ret, location, jump, then_label);
1021}
1022
1026static void
1027pm_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)
1028{
1029 const pm_node_location_t location = *node_location;
1030 LABEL *then_label = NEW_LABEL(location.line);
1031 LABEL *else_label = NEW_LABEL(location.line);
1032 LABEL *end_label = NULL;
1033
1034 DECL_ANCHOR(cond_seq);
1035 pm_compile_branch_condition(iseq, cond_seq, predicate, then_label, else_label, false, scope_node);
1036 PUSH_SEQ(ret, cond_seq);
1037
1038 rb_code_location_t conditional_location = { 0 };
1039 VALUE branches = Qfalse;
1040
1041 if (then_label->refcnt && else_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1042 conditional_location = pm_code_location(scope_node, node);
1043 branches = decl_branch_base(iseq, PTR2NUM(node), &conditional_location, type == PM_IF_NODE ? "if" : "unless");
1044 }
1045
1046 if (then_label->refcnt) {
1047 PUSH_LABEL(ret, then_label);
1048
1049 DECL_ANCHOR(then_seq);
1050
1051 if (statements != NULL) {
1052 pm_compile_node(iseq, (const pm_node_t *) statements, then_seq, popped, scope_node);
1053 }
1054 else if (!popped) {
1055 PUSH_SYNTHETIC_PUTNIL(then_seq, iseq);
1056 }
1057
1058 if (else_label->refcnt) {
1059 // Establish branch coverage for the then block.
1060 if (PM_BRANCH_COVERAGE_P(iseq)) {
1061 rb_code_location_t branch_location;
1062
1063 if (statements != NULL) {
1064 branch_location = pm_code_location(scope_node, (const pm_node_t *) statements);
1065 } else if (type == PM_IF_NODE) {
1066 pm_line_column_t predicate_end = PM_NODE_END_LINE_COLUMN(scope_node->parser, predicate);
1067 branch_location = (rb_code_location_t) {
1068 .beg_pos = { .lineno = predicate_end.line, .column = predicate_end.column },
1069 .end_pos = { .lineno = predicate_end.line, .column = predicate_end.column }
1070 };
1071 } else {
1072 branch_location = conditional_location;
1073 }
1074
1075 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0, type == PM_IF_NODE ? "then" : "else", branches);
1076 }
1077
1078 end_label = NEW_LABEL(location.line);
1079 PUSH_INSNL(then_seq, location, jump, end_label);
1080 if (!popped) PUSH_INSN(then_seq, location, pop);
1081 }
1082
1083 PUSH_SEQ(ret, then_seq);
1084 }
1085
1086 if (else_label->refcnt) {
1087 PUSH_LABEL(ret, else_label);
1088
1089 DECL_ANCHOR(else_seq);
1090
1091 if (subsequent != NULL) {
1092 pm_compile_node(iseq, subsequent, else_seq, popped, scope_node);
1093 }
1094 else if (!popped) {
1095 PUSH_SYNTHETIC_PUTNIL(else_seq, iseq);
1096 }
1097
1098 // Establish branch coverage for the else block.
1099 if (then_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1100 rb_code_location_t branch_location;
1101
1102 if (subsequent == NULL) {
1103 branch_location = conditional_location;
1104 } else if (PM_NODE_TYPE_P(subsequent, PM_ELSE_NODE)) {
1105 const pm_else_node_t *else_node = (const pm_else_node_t *) subsequent;
1106 branch_location = pm_code_location(scope_node, else_node->statements != NULL ? ((const pm_node_t *) else_node->statements) : (const pm_node_t *) else_node);
1107 } else {
1108 branch_location = pm_code_location(scope_node, (const pm_node_t *) subsequent);
1109 }
1110
1111 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 1, type == PM_IF_NODE ? "else" : "then", branches);
1112 }
1113
1114 PUSH_SEQ(ret, else_seq);
1115 }
1116
1117 if (end_label) {
1118 PUSH_LABEL(ret, end_label);
1119 }
1120
1121 return;
1122}
1123
1127static void
1128pm_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)
1129{
1130 const pm_node_location_t location = *node_location;
1131
1132 LABEL *prev_start_label = ISEQ_COMPILE_DATA(iseq)->start_label;
1133 LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label;
1134 LABEL *prev_redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label;
1135
1136 LABEL *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(location.line); /* next */
1137 LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(location.line); /* redo */
1138 LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(location.line); /* break */
1139 LABEL *end_label = NEW_LABEL(location.line);
1140 LABEL *adjust_label = NEW_LABEL(location.line);
1141
1142 LABEL *next_catch_label = NEW_LABEL(location.line);
1143 LABEL *tmp_label = NULL;
1144
1145 // We're pushing onto the ensure stack because breaks need to break out of
1146 // this loop and not break into the ensure statements within the same
1147 // lexical scope.
1148 struct iseq_compile_data_ensure_node_stack enl;
1149 push_ensure_entry(iseq, &enl, NULL, NULL);
1150
1151 // begin; end while true
1152 if (flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
1153 tmp_label = NEW_LABEL(location.line);
1154 PUSH_INSNL(ret, location, jump, tmp_label);
1155 }
1156 else {
1157 // while true; end
1158 PUSH_INSNL(ret, location, jump, next_label);
1159 }
1160
1161 PUSH_LABEL(ret, adjust_label);
1162 PUSH_INSN(ret, location, putnil);
1163 PUSH_LABEL(ret, next_catch_label);
1164 PUSH_INSN(ret, location, pop);
1165 PUSH_INSNL(ret, location, jump, next_label);
1166 if (tmp_label) PUSH_LABEL(ret, tmp_label);
1167
1168 PUSH_LABEL(ret, redo_label);
1169
1170 // Establish branch coverage for the loop.
1171 if (PM_BRANCH_COVERAGE_P(iseq)) {
1172 rb_code_location_t loop_location = pm_code_location(scope_node, node);
1173 VALUE branches = decl_branch_base(iseq, PTR2NUM(node), &loop_location, type == PM_WHILE_NODE ? "while" : "until");
1174
1175 rb_code_location_t branch_location = statements != NULL ? pm_code_location(scope_node, (const pm_node_t *) statements) : loop_location;
1176 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0, "body", branches);
1177 }
1178
1179 if (statements != NULL) PM_COMPILE_POPPED((const pm_node_t *) statements);
1180 PUSH_LABEL(ret, next_label);
1181
1182 if (type == PM_WHILE_NODE) {
1183 pm_compile_branch_condition(iseq, ret, predicate, redo_label, end_label, popped, scope_node);
1184 }
1185 else if (type == PM_UNTIL_NODE) {
1186 pm_compile_branch_condition(iseq, ret, predicate, end_label, redo_label, popped, scope_node);
1187 }
1188
1189 PUSH_LABEL(ret, end_label);
1190 PUSH_ADJUST_RESTORE(ret, adjust_label);
1191 PUSH_INSN(ret, location, putnil);
1192
1193 PUSH_LABEL(ret, break_label);
1194 if (popped) PUSH_INSN(ret, location, pop);
1195
1196 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label, NULL, break_label);
1197 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, NULL, next_catch_label);
1198 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, NULL, ISEQ_COMPILE_DATA(iseq)->redo_label);
1199
1200 ISEQ_COMPILE_DATA(iseq)->start_label = prev_start_label;
1201 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label;
1202 ISEQ_COMPILE_DATA(iseq)->redo_label = prev_redo_label;
1203 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->prev;
1204
1205 return;
1206}
1207
1208// This recurses through scopes and finds the local index at any scope level
1209// It also takes a pointer to depth, and increments depth appropriately
1210// according to the depth of the local.
1211static pm_local_index_t
1212pm_lookup_local_index(rb_iseq_t *iseq, const pm_scope_node_t *scope_node, pm_constant_id_t constant_id, int start_depth)
1213{
1214 pm_local_index_t lindex = { 0 };
1215 st_data_t local_index;
1216
1217 int level;
1218 for (level = 0; level < start_depth; level++) {
1219 scope_node = scope_node->previous;
1220 }
1221
1222 while (!st_lookup(scope_node->index_lookup_table, constant_id, &local_index)) {
1223 level++;
1224
1225 if (scope_node->previous) {
1226 scope_node = scope_node->previous;
1227 }
1228 else {
1229 // We have recursed up all scope nodes
1230 // and have not found the local yet
1231 rb_bug("Local with constant_id %u does not exist", (unsigned int) constant_id);
1232 }
1233 }
1234
1235 lindex.level = level;
1236 lindex.index = scope_node->local_table_for_iseq_size - (int) local_index;
1237 return lindex;
1238}
1239
1240// This returns the CRuby ID which maps to the pm_constant_id_t
1241//
1242// Constant_ids in prism are indexes of the constants in prism's constant pool.
1243// We add a constants mapping on the scope_node which is a mapping from
1244// these constant_id indexes to the CRuby IDs that they represent.
1245// This helper method allows easy access to those IDs
1246static ID
1247pm_constant_id_lookup(const pm_scope_node_t *scope_node, pm_constant_id_t constant_id)
1248{
1249 if (constant_id < 1 || constant_id > scope_node->parser->constant_pool.size) {
1250 rb_bug("constant_id out of range: %u", (unsigned int)constant_id);
1251 }
1252 return scope_node->constants[constant_id - 1];
1253}
1254
1255static rb_iseq_t *
1256pm_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)
1257{
1258 debugs("[new_child_iseq]> ---------------------------------------\n");
1259 int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth;
1260 int error_state;
1261 rb_iseq_t *ret_iseq = pm_iseq_new_with_opt(node, name,
1262 rb_iseq_path(iseq), rb_iseq_realpath(iseq),
1263 line_no, parent,
1264 isolated_depth ? isolated_depth + 1 : 0,
1265 type, ISEQ_COMPILE_DATA(iseq)->option, &error_state);
1266
1267 if (error_state) {
1268 RUBY_ASSERT(ret_iseq == NULL);
1269 rb_jump_tag(error_state);
1270 }
1271 debugs("[new_child_iseq]< ---------------------------------------\n");
1272 return ret_iseq;
1273}
1274
1275static int
1276pm_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)
1277{
1278 if (PM_NODE_TYPE_P(node, PM_CONSTANT_PATH_NODE)) {
1279 const pm_node_t *parent = ((const pm_constant_path_node_t *) node)->parent;
1280
1281 if (parent) {
1282 /* Bar::Foo */
1283 PM_COMPILE(parent);
1284 return VM_DEFINECLASS_FLAG_SCOPED;
1285 }
1286 else {
1287 /* toplevel class ::Foo */
1288 PUSH_INSN1(ret, *node_location, putobject, rb_cObject);
1289 return VM_DEFINECLASS_FLAG_SCOPED;
1290 }
1291 }
1292 else {
1293 /* class at cbase Foo */
1294 PUSH_INSN1(ret, *node_location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
1295 return 0;
1296 }
1297}
1298
1303static void
1304pm_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)
1305{
1306 const pm_node_location_t location = *node_location;
1307 LABEL *lfin = NEW_LABEL(location.line);
1308 LABEL *lcfin = NEW_LABEL(location.line);
1309 LABEL *lskip = NULL;
1310
1311 int flag = PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
1312 ID id_read_name = pm_constant_id_lookup(scope_node, read_name);
1313
1314 PM_COMPILE_NOT_POPPED(receiver);
1315 if (safe_nav) {
1316 lskip = NEW_LABEL(location.line);
1317 PUSH_INSN(ret, location, dup);
1318 PUSH_INSNL(ret, location, branchnil, lskip);
1319 }
1320
1321 PUSH_INSN(ret, location, dup);
1322 PUSH_SEND_WITH_FLAG(ret, location, id_read_name, INT2FIX(0), INT2FIX(flag));
1323 if (!popped) PUSH_INSN(ret, location, dup);
1324
1325 if (and_node) {
1326 PUSH_INSNL(ret, location, branchunless, lcfin);
1327 }
1328 else {
1329 PUSH_INSNL(ret, location, branchif, lcfin);
1330 }
1331
1332 if (!popped) PUSH_INSN(ret, location, pop);
1333 PM_COMPILE_NOT_POPPED(value);
1334
1335 if (!popped) {
1336 PUSH_INSN(ret, location, swap);
1337 PUSH_INSN1(ret, location, topn, INT2FIX(1));
1338 }
1339
1340 ID id_write_name = pm_constant_id_lookup(scope_node, write_name);
1341 PUSH_SEND_WITH_FLAG(ret, location, id_write_name, INT2FIX(1), INT2FIX(flag));
1342 PUSH_INSNL(ret, location, jump, lfin);
1343
1344 PUSH_LABEL(ret, lcfin);
1345 if (!popped) PUSH_INSN(ret, location, swap);
1346
1347 PUSH_LABEL(ret, lfin);
1348
1349 if (lskip && popped) PUSH_LABEL(ret, lskip);
1350 PUSH_INSN(ret, location, pop);
1351 if (lskip && !popped) PUSH_LABEL(ret, lskip);
1352}
1353
1354static 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);
1355
1361static void
1362pm_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)
1363{
1364 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
1365
1366 // If this element is not popped, then we need to create the hash on the
1367 // stack. Neighboring plain assoc nodes should be grouped together (either
1368 // by newhash or hash merge). Double splat nodes should be merged using the
1369 // merge_kwd method call.
1370 const int max_stack_length = 0x100;
1371 const unsigned int min_tmp_hash_length = 0x800;
1372
1373 int stack_length = 0;
1374 bool first_chunk = true;
1375
1376 // This is an optimization wherein we keep track of whether or not the
1377 // previous element was a static literal. If it was, then we do not attempt
1378 // to check if we have a subhash that can be optimized. If it was not, then
1379 // we do check.
1380 bool static_literal = false;
1381
1382 DECL_ANCHOR(anchor);
1383
1384 // Convert pushed elements to a hash, and merge if needed.
1385#define FLUSH_CHUNK \
1386 if (stack_length) { \
1387 if (first_chunk) { \
1388 PUSH_SEQ(ret, anchor); \
1389 PUSH_INSN1(ret, location, newhash, INT2FIX(stack_length)); \
1390 first_chunk = false; \
1391 } \
1392 else { \
1393 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); \
1394 PUSH_INSN(ret, location, swap); \
1395 PUSH_SEQ(ret, anchor); \
1396 PUSH_SEND(ret, location, id_core_hash_merge_ptr, INT2FIX(stack_length + 1)); \
1397 } \
1398 INIT_ANCHOR(anchor); \
1399 stack_length = 0; \
1400 }
1401
1402 for (size_t index = 0; index < elements->size; index++) {
1403 const pm_node_t *element = elements->nodes[index];
1404
1405 switch (PM_NODE_TYPE(element)) {
1406 case PM_ASSOC_NODE: {
1407 // Pre-allocation check (this branch can be omitted).
1408 if (
1409 (shareability == 0) &&
1410 PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL) && (
1411 (!static_literal && ((index + min_tmp_hash_length) < elements->size)) ||
1412 (first_chunk && stack_length == 0)
1413 )
1414 ) {
1415 // Count the elements that are statically-known.
1416 size_t count = 1;
1417 while (index + count < elements->size && PM_NODE_FLAG_P(elements->nodes[index + count], PM_NODE_FLAG_STATIC_LITERAL)) count++;
1418
1419 if ((first_chunk && stack_length == 0) || count >= min_tmp_hash_length) {
1420 // The subsequence of elements in this hash is long enough
1421 // to merit its own hash.
1422 VALUE ary = rb_ary_hidden_new(count);
1423
1424 // Create a hidden hash.
1425 for (size_t tmp_end = index + count; index < tmp_end; index++) {
1426 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[index];
1427
1428 VALUE elem[2] = {
1429 pm_static_literal_value(iseq, assoc->key, scope_node),
1430 pm_static_literal_value(iseq, assoc->value, scope_node)
1431 };
1432
1433 rb_ary_cat(ary, elem, 2);
1434 }
1435 index --;
1436
1437 VALUE hash = rb_hash_new_with_size(RARRAY_LEN(ary) / 2);
1438 rb_hash_bulk_insert(RARRAY_LEN(ary), RARRAY_CONST_PTR(ary), hash);
1439 hash = rb_obj_hide(hash);
1440 OBJ_FREEZE(hash);
1441
1442 // Emit optimized code.
1443 FLUSH_CHUNK;
1444 if (first_chunk) {
1445 PUSH_INSN1(ret, location, duphash, hash);
1446 first_chunk = false;
1447 }
1448 else {
1449 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1450 PUSH_INSN(ret, location, swap);
1451 PUSH_INSN1(ret, location, putobject, hash);
1452 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1453 }
1454
1455 break;
1456 }
1457 else {
1458 static_literal = true;
1459 }
1460 }
1461 else {
1462 static_literal = false;
1463 }
1464
1465 // If this is a plain assoc node, then we can compile it directly
1466 // and then add the total number of values on the stack.
1467 if (shareability == 0) {
1468 pm_compile_node(iseq, element, anchor, false, scope_node);
1469 }
1470 else {
1471 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
1472 pm_compile_shareable_constant_value(iseq, assoc->key, shareability, path, ret, scope_node, false);
1473 pm_compile_shareable_constant_value(iseq, assoc->value, shareability, path, ret, scope_node, false);
1474 }
1475
1476 if ((stack_length += 2) >= max_stack_length) FLUSH_CHUNK;
1477 break;
1478 }
1479 case PM_ASSOC_SPLAT_NODE: {
1480 FLUSH_CHUNK;
1481
1482 const pm_assoc_splat_node_t *assoc_splat = (const pm_assoc_splat_node_t *) element;
1483 bool empty_hash = assoc_splat->value != NULL && (
1484 (PM_NODE_TYPE_P(assoc_splat->value, PM_HASH_NODE) && ((const pm_hash_node_t *) assoc_splat->value)->elements.size == 0) ||
1485 PM_NODE_TYPE_P(assoc_splat->value, PM_NIL_NODE)
1486 );
1487
1488 bool first_element = first_chunk && stack_length == 0;
1489 bool last_element = index == elements->size - 1;
1490 bool only_element = first_element && last_element;
1491
1492 if (empty_hash) {
1493 if (only_element && argument) {
1494 // **{} appears at the only keyword argument in method call,
1495 // so it won't be modified.
1496 //
1497 // This is only done for method calls and not for literal
1498 // hashes, because literal hashes should always result in a
1499 // new hash.
1500 PUSH_INSN(ret, location, putnil);
1501 }
1502 else if (first_element) {
1503 // **{} appears as the first keyword argument, so it may be
1504 // modified. We need to create a fresh hash object.
1505 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1506 }
1507 // Any empty keyword splats that are not the first can be
1508 // ignored since merging an empty hash into the existing hash is
1509 // the same as not merging it.
1510 }
1511 else {
1512 if (only_element && argument) {
1513 // ** is only keyword argument in the method call. Use it
1514 // directly. This will be not be flagged as mutable. This is
1515 // only done for method calls and not for literal hashes,
1516 // because literal hashes should always result in a new
1517 // hash.
1518 if (shareability == 0) {
1519 PM_COMPILE_NOT_POPPED(element);
1520 }
1521 else {
1522 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node, false);
1523 }
1524 }
1525 else {
1526 // There is more than one keyword argument, or this is not a
1527 // method call. In that case, we need to add an empty hash
1528 // (if first keyword), or merge the hash to the accumulated
1529 // hash (if not the first keyword).
1530 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1531
1532 if (first_element) {
1533 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1534 }
1535 else {
1536 PUSH_INSN(ret, location, swap);
1537 }
1538
1539 if (shareability == 0) {
1540 PM_COMPILE_NOT_POPPED(element);
1541 }
1542 else {
1543 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node, false);
1544 }
1545
1546 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1547 }
1548 }
1549
1550 first_chunk = false;
1551 static_literal = false;
1552 break;
1553 }
1554 default:
1555 RUBY_ASSERT("Invalid node type for hash" && false);
1556 break;
1557 }
1558 }
1559
1560 FLUSH_CHUNK;
1561#undef FLUSH_CHUNK
1562}
1563
1564#define SPLATARRAY_FALSE 0
1565#define SPLATARRAY_TRUE 1
1566#define DUP_SINGLE_KW_SPLAT 2
1567
1568// This is details. Users should call pm_setup_args() instead.
1569static int
1570pm_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)
1571{
1572 const pm_node_location_t location = *node_location;
1573
1574 int orig_argc = 0;
1575 bool has_splat = false;
1576 bool has_keyword_splat = false;
1577
1578 if (arguments_node == NULL) {
1579 if (*flags & VM_CALL_FCALL) {
1580 *flags |= VM_CALL_VCALL;
1581 }
1582 }
1583 else {
1584 const pm_node_list_t *arguments = &arguments_node->arguments;
1585 has_keyword_splat = PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT);
1586
1587 // We count the number of elements post the splat node that are not keyword elements to
1588 // eventually pass as an argument to newarray
1589 int post_splat_counter = 0;
1590 const pm_node_t *argument;
1591
1592 PM_NODE_LIST_FOREACH(arguments, index, argument) {
1593 switch (PM_NODE_TYPE(argument)) {
1594 // A keyword hash node contains all keyword arguments as AssocNodes and AssocSplatNodes
1595 case PM_KEYWORD_HASH_NODE: {
1596 const pm_keyword_hash_node_t *keyword_arg = (const pm_keyword_hash_node_t *) argument;
1597 const pm_node_list_t *elements = &keyword_arg->elements;
1598
1599 if (has_keyword_splat || has_splat) {
1600 *flags |= VM_CALL_KW_SPLAT;
1601 has_keyword_splat = true;
1602
1603 if (elements->size > 1 || !(elements->size == 1 && PM_NODE_TYPE_P(elements->nodes[0], PM_ASSOC_SPLAT_NODE))) {
1604 // A new hash will be created for the keyword arguments
1605 // in this case, so mark the method as passing mutable
1606 // keyword splat.
1607 *flags |= VM_CALL_KW_SPLAT_MUT;
1608 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1609 }
1610 else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
1611 *flags |= VM_CALL_KW_SPLAT_MUT;
1612 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1613 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
1614 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1615 PUSH_SEND(ret, location, id_core_hash_merge_kwd, INT2FIX(2));
1616 }
1617 else {
1618 pm_compile_hash_elements(iseq, argument, elements, 0, Qundef, true, ret, scope_node);
1619 }
1620 }
1621 else {
1622 // We need to first figure out if all elements of the
1623 // KeywordHashNode are AssocNodes with symbol keys.
1624 if (PM_NODE_FLAG_P(keyword_arg, PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS)) {
1625 // If they are all symbol keys then we can pass them as
1626 // keyword arguments. The first thing we need to do is
1627 // deduplicate. We'll do this using the combination of a
1628 // Ruby hash and a Ruby array.
1629 VALUE stored_indices = rb_hash_new();
1630 VALUE keyword_indices = rb_ary_new_capa(elements->size);
1631
1632 size_t size = 0;
1633 for (size_t element_index = 0; element_index < elements->size; element_index++) {
1634 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1635
1636 // Retrieve the stored index from the hash for this
1637 // keyword.
1638 VALUE keyword = pm_static_literal_value(iseq, assoc->key, scope_node);
1639 VALUE stored_index = rb_hash_aref(stored_indices, keyword);
1640
1641 // If this keyword was already seen in the hash,
1642 // then mark the array at that index as false and
1643 // decrement the keyword size.
1644 if (!NIL_P(stored_index)) {
1645 rb_ary_store(keyword_indices, NUM2LONG(stored_index), Qfalse);
1646 size--;
1647 }
1648
1649 // Store (and possibly overwrite) the index for this
1650 // keyword in the hash, mark the array at that index
1651 // as true, and increment the keyword size.
1652 rb_hash_aset(stored_indices, keyword, ULONG2NUM(element_index));
1653 rb_ary_store(keyword_indices, (long) element_index, Qtrue);
1654 size++;
1655 }
1656
1657 *kw_arg = rb_xmalloc_mul_add(size, sizeof(VALUE), sizeof(struct rb_callinfo_kwarg));
1658 *flags |= VM_CALL_KWARG;
1659
1660 VALUE *keywords = (*kw_arg)->keywords;
1661 (*kw_arg)->references = 0;
1662 (*kw_arg)->keyword_len = (int) size;
1663
1664 size_t keyword_index = 0;
1665 for (size_t element_index = 0; element_index < elements->size; element_index++) {
1666 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1667 bool popped = true;
1668
1669 if (rb_ary_entry(keyword_indices, (long) element_index) == Qtrue) {
1670 keywords[keyword_index++] = pm_static_literal_value(iseq, assoc->key, scope_node);
1671 popped = false;
1672 }
1673
1674 PM_COMPILE(assoc->value);
1675 }
1676
1677 RUBY_ASSERT(keyword_index == size);
1678 }
1679 else {
1680 // If they aren't all symbol keys then we need to
1681 // construct a new hash and pass that as an argument.
1682 orig_argc++;
1683 *flags |= VM_CALL_KW_SPLAT;
1684
1685 size_t size = elements->size;
1686 if (size > 1) {
1687 // A new hash will be created for the keyword
1688 // arguments in this case, so mark the method as
1689 // passing mutable keyword splat.
1690 *flags |= VM_CALL_KW_SPLAT_MUT;
1691 }
1692
1693 for (size_t element_index = 0; element_index < size; element_index++) {
1694 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) elements->nodes[element_index];
1695 PM_COMPILE_NOT_POPPED(assoc->key);
1696 PM_COMPILE_NOT_POPPED(assoc->value);
1697 }
1698
1699 PUSH_INSN1(ret, location, newhash, INT2FIX(size * 2));
1700 }
1701 }
1702 break;
1703 }
1704 case PM_SPLAT_NODE: {
1705 *flags |= VM_CALL_ARGS_SPLAT;
1706 const pm_splat_node_t *splat_node = (const pm_splat_node_t *) argument;
1707
1708 if (splat_node->expression) {
1709 PM_COMPILE_NOT_POPPED(splat_node->expression);
1710 }
1711 else {
1712 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1713 PUSH_GETLOCAL(ret, location, index.index, index.level);
1714 }
1715
1716 bool first_splat = !has_splat;
1717
1718 if (first_splat) {
1719 // If this is the first splat array seen and it's not the
1720 // last parameter, we want splatarray to dup it.
1721 //
1722 // foo(a, *b, c)
1723 // ^^
1724 if (index + 1 < arguments->size || has_regular_blockarg) {
1725 PUSH_INSN1(ret, location, splatarray, (*dup_rest & SPLATARRAY_TRUE) ? Qtrue : Qfalse);
1726 if (*dup_rest & SPLATARRAY_TRUE) *dup_rest &= ~SPLATARRAY_TRUE;
1727 }
1728 // If this is the first spalt array seen and it's the last
1729 // parameter, we don't want splatarray to dup it.
1730 //
1731 // foo(a, *b)
1732 // ^^
1733 else {
1734 PUSH_INSN1(ret, location, splatarray, Qfalse);
1735 }
1736 }
1737 else {
1738 // If this is not the first splat array seen and it is also
1739 // the last parameter, we don't want splatarray to dup it
1740 // and we need to concat the array.
1741 //
1742 // foo(a, *b, *c)
1743 // ^^
1744 PUSH_INSN(ret, location, concattoarray);
1745 }
1746
1747 has_splat = true;
1748 post_splat_counter = 0;
1749
1750 break;
1751 }
1752 case PM_FORWARDING_ARGUMENTS_NODE: { // not counted in argc return value
1753 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
1754
1755 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
1756 *flags |= VM_CALL_FORWARDING;
1757
1758 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
1759 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1760
1761 break;
1762 }
1763
1764 orig_argc += 2;
1765
1766 *flags |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT | VM_CALL_ARGS_BLOCKARG | VM_CALL_KW_SPLAT;
1767
1768 // Forwarding arguments nodes are treated as foo(*, **, &)
1769 // So foo(...) equals foo(*, **, &) and as such the local
1770 // table for this method is known in advance
1771 //
1772 // Push the *
1773 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1774 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1775 PUSH_INSN1(ret, location, splatarray, Qtrue);
1776
1777 // Push the **
1778 pm_local_index_t pow_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
1779 PUSH_GETLOCAL(ret, location, pow_local.index, pow_local.level);
1780
1781 // Push the &
1782 pm_local_index_t and_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
1783 PUSH_INSN2(ret, location, getblockparamproxy, INT2FIX(and_local.index + VM_ENV_DATA_SIZE - 1), INT2FIX(and_local.level));
1784 PUSH_INSN(ret, location, splatkw);
1785
1786 break;
1787 }
1788 default: {
1789 post_splat_counter++;
1790 PM_COMPILE_NOT_POPPED(argument);
1791
1792 // If we have a splat and we've seen a splat, we need to process
1793 // everything after the splat.
1794 if (has_splat) {
1795 // Stack items are turned into an array and concatenated in
1796 // the following cases:
1797 //
1798 // If the next node is a splat:
1799 //
1800 // foo(*a, b, *c)
1801 //
1802 // If the next node is a kwarg or kwarg splat:
1803 //
1804 // foo(*a, b, c: :d)
1805 // foo(*a, b, **c)
1806 //
1807 // If the next node is NULL (we have hit the end):
1808 //
1809 // foo(*a, b)
1810 if (index == arguments->size - 1) {
1811 RUBY_ASSERT(post_splat_counter > 0);
1812 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(post_splat_counter));
1813 }
1814 else {
1815 pm_node_t *next_arg = arguments->nodes[index + 1];
1816
1817 switch (PM_NODE_TYPE(next_arg)) {
1818 // A keyword hash node contains all keyword arguments as AssocNodes and AssocSplatNodes
1819 case PM_KEYWORD_HASH_NODE: {
1820 PUSH_INSN1(ret, location, newarray, INT2FIX(post_splat_counter));
1821 PUSH_INSN(ret, location, concatarray);
1822 break;
1823 }
1824 case PM_SPLAT_NODE: {
1825 PUSH_INSN1(ret, location, newarray, INT2FIX(post_splat_counter));
1826 PUSH_INSN(ret, location, concatarray);
1827 break;
1828 }
1829 default:
1830 break;
1831 }
1832 }
1833 }
1834 else {
1835 orig_argc++;
1836 }
1837 }
1838 }
1839 }
1840 }
1841
1842 if (has_splat) orig_argc++;
1843 if (has_keyword_splat) orig_argc++;
1844 return orig_argc;
1845}
1846
1851static inline bool
1852pm_setup_args_dup_rest_p(const pm_node_t *node)
1853{
1854 switch (PM_NODE_TYPE(node)) {
1855 case PM_BACK_REFERENCE_READ_NODE:
1856 case PM_CLASS_VARIABLE_READ_NODE:
1857 case PM_CONSTANT_PATH_NODE:
1858 case PM_CONSTANT_READ_NODE:
1859 case PM_FALSE_NODE:
1860 case PM_FLOAT_NODE:
1861 case PM_GLOBAL_VARIABLE_READ_NODE:
1862 case PM_IMAGINARY_NODE:
1863 case PM_INSTANCE_VARIABLE_READ_NODE:
1864 case PM_INTEGER_NODE:
1865 case PM_LAMBDA_NODE:
1866 case PM_LOCAL_VARIABLE_READ_NODE:
1867 case PM_NIL_NODE:
1868 case PM_NUMBERED_REFERENCE_READ_NODE:
1869 case PM_RATIONAL_NODE:
1870 case PM_REGULAR_EXPRESSION_NODE:
1871 case PM_SELF_NODE:
1872 case PM_STRING_NODE:
1873 case PM_SYMBOL_NODE:
1874 case PM_TRUE_NODE:
1875 return false;
1876 case PM_IMPLICIT_NODE:
1877 return pm_setup_args_dup_rest_p(((const pm_implicit_node_t *) node)->value);
1878 default:
1879 return true;
1880 }
1881}
1882
1886static int
1887pm_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)
1888{
1889 int dup_rest = SPLATARRAY_TRUE;
1890
1891 const pm_node_list_t *arguments;
1892 size_t arguments_size;
1893
1894 // Calls like foo(1, *f, **hash) that use splat and kwsplat could be
1895 // eligible for eliding duping the rest array (dup_reset=false).
1896 if (
1897 arguments_node != NULL &&
1898 (arguments = &arguments_node->arguments, arguments_size = arguments->size) >= 2 &&
1899 PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT) &&
1900 !PM_NODE_FLAG_P(arguments_node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS) &&
1901 PM_NODE_TYPE_P(arguments->nodes[arguments_size - 1], PM_KEYWORD_HASH_NODE)
1902 ) {
1903 // Start by assuming that dup_rest=false, then check each element of the
1904 // hash to ensure we don't need to flip it back to true (in case one of
1905 // the elements could potentially mutate the array).
1906 dup_rest = SPLATARRAY_FALSE;
1907
1908 const pm_keyword_hash_node_t *keyword_hash = (const pm_keyword_hash_node_t *) arguments->nodes[arguments_size - 1];
1909 const pm_node_list_t *elements = &keyword_hash->elements;
1910
1911 for (size_t index = 0; dup_rest == SPLATARRAY_FALSE && index < elements->size; index++) {
1912 const pm_node_t *element = elements->nodes[index];
1913
1914 switch (PM_NODE_TYPE(element)) {
1915 case PM_ASSOC_NODE: {
1916 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
1917 if (pm_setup_args_dup_rest_p(assoc->key) || pm_setup_args_dup_rest_p(assoc->value)) dup_rest = SPLATARRAY_TRUE;
1918 break;
1919 }
1920 case PM_ASSOC_SPLAT_NODE: {
1921 const pm_assoc_splat_node_t *assoc = (const pm_assoc_splat_node_t *) element;
1922 if (assoc->value != NULL && pm_setup_args_dup_rest_p(assoc->value)) dup_rest = SPLATARRAY_TRUE;
1923 break;
1924 }
1925 default:
1926 break;
1927 }
1928 }
1929 }
1930
1931 int initial_dup_rest = dup_rest;
1932 int argc;
1933
1934 if (block && PM_NODE_TYPE_P(block, PM_BLOCK_ARGUMENT_NODE)) {
1935 // We compile the `&block_arg` expression first and stitch it later
1936 // since the nature of the expression influences whether splat should
1937 // duplicate the array.
1938 bool regular_block_arg = true;
1939 const pm_node_t *block_expr = ((const pm_block_argument_node_t *)block)->expression;
1940
1941 if (block_expr && pm_setup_args_dup_rest_p(block_expr)) {
1942 dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
1943 initial_dup_rest = dup_rest;
1944 }
1945
1946 DECL_ANCHOR(block_arg);
1947 pm_compile_node(iseq, block, block_arg, false, scope_node);
1948
1949 *flags |= VM_CALL_ARGS_BLOCKARG;
1950
1951 if (LIST_INSN_SIZE_ONE(block_arg)) {
1952 LINK_ELEMENT *elem = FIRST_ELEMENT(block_arg);
1953 if (IS_INSN(elem)) {
1954 INSN *iobj = (INSN *) elem;
1955 if (iobj->insn_id == BIN(getblockparam)) {
1956 iobj->insn_id = BIN(getblockparamproxy);
1957 }
1958
1959 // Allow splat without duplication for simple one-instruction
1960 // block arguments like `&arg`. It is known that this
1961 // optimization can be too aggressive in some cases. See
1962 // [Bug #16504].
1963 regular_block_arg = false;
1964 }
1965 }
1966
1967 argc = pm_setup_args_core(arguments_node, block, flags, regular_block_arg, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1968 PUSH_SEQ(ret, block_arg);
1969 }
1970 else {
1971 argc = pm_setup_args_core(arguments_node, block, flags, false, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1972 }
1973
1974 // If the dup_rest flag was consumed while compiling the arguments (which
1975 // effectively means we found the splat node), then it would have changed
1976 // during the call to pm_setup_args_core. In this case, we want to add the
1977 // VM_CALL_ARGS_SPLAT_MUT flag.
1978 if (*flags & VM_CALL_ARGS_SPLAT && dup_rest != initial_dup_rest) {
1979 *flags |= VM_CALL_ARGS_SPLAT_MUT;
1980 }
1981
1982 return argc;
1983}
1984
1995static void
1996pm_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)
1997{
1998 const pm_node_location_t location = *node_location;
1999 if (!popped) PUSH_INSN(ret, location, putnil);
2000
2001 PM_COMPILE_NOT_POPPED(node->receiver);
2002
2003 int boff = (node->block == NULL ? 0 : 1);
2004 int flag = PM_NODE_TYPE_P(node->receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
2005 struct rb_callinfo_kwarg *keywords = NULL;
2006 int argc = pm_setup_args(node->arguments, (const pm_node_t *) node->block, &flag, &keywords, iseq, ret, scope_node, node_location);
2007
2008 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2009 if (boff) {
2010 PUSH_INSN(ret, location, splatkw);
2011 }
2012 else {
2013 PUSH_INSN(ret, location, dup);
2014 PUSH_INSN(ret, location, splatkw);
2015 PUSH_INSN(ret, location, pop);
2016 }
2017 }
2018
2019 int dup_argn = argc + 1 + boff;
2020 int keyword_len = 0;
2021
2022 if (keywords) {
2023 keyword_len = keywords->keyword_len;
2024 dup_argn += keyword_len;
2025 }
2026
2027 PUSH_INSN1(ret, location, dupn, INT2FIX(dup_argn));
2028 PUSH_SEND_R(ret, location, idAREF, INT2FIX(argc), NULL, INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2029 PM_COMPILE_NOT_POPPED(node->value);
2030
2031 ID id_operator = pm_constant_id_lookup(scope_node, node->binary_operator);
2032 PUSH_SEND(ret, location, id_operator, INT2FIX(1));
2033
2034 if (!popped) {
2035 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2036 }
2037 if (flag & VM_CALL_ARGS_SPLAT) {
2038 if (flag & VM_CALL_KW_SPLAT) {
2039 PUSH_INSN1(ret, location, topn, INT2FIX(2 + boff));
2040
2041 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2042 PUSH_INSN1(ret, location, splatarray, Qtrue);
2043 flag |= VM_CALL_ARGS_SPLAT_MUT;
2044 }
2045
2046 PUSH_INSN(ret, location, swap);
2047 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2048 PUSH_INSN1(ret, location, setn, INT2FIX(2 + boff));
2049 PUSH_INSN(ret, location, pop);
2050 }
2051 else {
2052 if (boff > 0) {
2053 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2054 PUSH_INSN(ret, location, swap);
2055 PUSH_INSN(ret, location, pop);
2056 }
2057 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2058 PUSH_INSN(ret, location, swap);
2059 PUSH_INSN1(ret, location, splatarray, Qtrue);
2060 PUSH_INSN(ret, location, swap);
2061 flag |= VM_CALL_ARGS_SPLAT_MUT;
2062 }
2063 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2064 if (boff > 0) {
2065 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2066 PUSH_INSN(ret, location, pop);
2067 PUSH_INSN(ret, location, pop);
2068 }
2069 }
2070
2071 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc), NULL, INT2FIX(flag), keywords);
2072 }
2073 else if (flag & VM_CALL_KW_SPLAT) {
2074 if (boff > 0) {
2075 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2076 PUSH_INSN(ret, location, swap);
2077 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2078 PUSH_INSN(ret, location, pop);
2079 }
2080 PUSH_INSN(ret, location, swap);
2081 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2082 }
2083 else if (keyword_len) {
2084 PUSH_INSN(ret, location, dup);
2085 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 2));
2086 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 1));
2087 PUSH_INSN(ret, location, pop);
2088 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2089 }
2090 else {
2091 if (boff > 0) {
2092 PUSH_INSN(ret, location, swap);
2093 }
2094 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2095 }
2096
2097 PUSH_INSN(ret, location, pop);
2098}
2099
2112static void
2113pm_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)
2114{
2115 const pm_node_location_t location = *node_location;
2116 if (!popped) PUSH_INSN(ret, location, putnil);
2117 PM_COMPILE_NOT_POPPED(receiver);
2118
2119 int boff = (block == NULL ? 0 : 1);
2120 int flag = PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? VM_CALL_FCALL : 0;
2121 struct rb_callinfo_kwarg *keywords = NULL;
2122 int argc = pm_setup_args(arguments, (const pm_node_t *) block, &flag, &keywords, iseq, ret, scope_node, node_location);
2123
2124 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2125 if (boff) {
2126 PUSH_INSN(ret, location, splatkw);
2127 }
2128 else {
2129 PUSH_INSN(ret, location, dup);
2130 PUSH_INSN(ret, location, splatkw);
2131 PUSH_INSN(ret, location, pop);
2132 }
2133 }
2134
2135 int dup_argn = argc + 1 + boff;
2136 int keyword_len = 0;
2137
2138 if (keywords) {
2139 keyword_len = keywords->keyword_len;
2140 dup_argn += keyword_len;
2141 }
2142
2143 PUSH_INSN1(ret, location, dupn, INT2FIX(dup_argn));
2144 PUSH_SEND_R(ret, location, idAREF, INT2FIX(argc), NULL, INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2145
2146 LABEL *label = NEW_LABEL(location.line);
2147 LABEL *lfin = NEW_LABEL(location.line);
2148
2149 PUSH_INSN(ret, location, dup);
2150 if (PM_NODE_TYPE_P(node, PM_INDEX_AND_WRITE_NODE)) {
2151 PUSH_INSNL(ret, location, branchunless, label);
2152 }
2153 else {
2154 PUSH_INSNL(ret, location, branchif, label);
2155 }
2156
2157 PUSH_INSN(ret, location, pop);
2158 PM_COMPILE_NOT_POPPED(value);
2159
2160 if (!popped) {
2161 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2162 }
2163
2164 if (flag & VM_CALL_ARGS_SPLAT) {
2165 if (flag & VM_CALL_KW_SPLAT) {
2166 PUSH_INSN1(ret, location, topn, INT2FIX(2 + boff));
2167 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2168 PUSH_INSN1(ret, location, splatarray, Qtrue);
2169 flag |= VM_CALL_ARGS_SPLAT_MUT;
2170 }
2171
2172 PUSH_INSN(ret, location, swap);
2173 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2174 PUSH_INSN1(ret, location, setn, INT2FIX(2 + boff));
2175 PUSH_INSN(ret, location, pop);
2176 }
2177 else {
2178 if (boff > 0) {
2179 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2180 PUSH_INSN(ret, location, swap);
2181 PUSH_INSN(ret, location, pop);
2182 }
2183 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2184 PUSH_INSN(ret, location, swap);
2185 PUSH_INSN1(ret, location, splatarray, Qtrue);
2186 PUSH_INSN(ret, location, swap);
2187 flag |= VM_CALL_ARGS_SPLAT_MUT;
2188 }
2189 PUSH_INSN1(ret, location, pushtoarray, INT2FIX(1));
2190 if (boff > 0) {
2191 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2192 PUSH_INSN(ret, location, pop);
2193 PUSH_INSN(ret, location, pop);
2194 }
2195 }
2196
2197 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc), NULL, INT2FIX(flag), keywords);
2198 }
2199 else if (flag & VM_CALL_KW_SPLAT) {
2200 if (boff > 0) {
2201 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2202 PUSH_INSN(ret, location, swap);
2203 PUSH_INSN1(ret, location, setn, INT2FIX(3));
2204 PUSH_INSN(ret, location, pop);
2205 }
2206
2207 PUSH_INSN(ret, location, swap);
2208 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2209 }
2210 else if (keyword_len) {
2211 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 1));
2212 PUSH_INSN1(ret, location, opt_reverse, INT2FIX(keyword_len + boff + 0));
2213 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2214 }
2215 else {
2216 if (boff > 0) {
2217 PUSH_INSN(ret, location, swap);
2218 }
2219 PUSH_SEND_R(ret, location, idASET, INT2FIX(argc + 1), NULL, INT2FIX(flag), keywords);
2220 }
2221
2222 PUSH_INSN(ret, location, pop);
2223 PUSH_INSNL(ret, location, jump, lfin);
2224 PUSH_LABEL(ret, label);
2225 if (!popped) {
2226 PUSH_INSN1(ret, location, setn, INT2FIX(dup_argn + 1));
2227 }
2228 PUSH_INSN1(ret, location, adjuststack, INT2FIX(dup_argn + 1));
2229 PUSH_LABEL(ret, lfin);
2230}
2231
2232// When we compile a pattern matching expression, we use the stack as a scratch
2233// space to store lots of different values (consider it like we have a pattern
2234// matching function and we need space for a bunch of different local
2235// variables). The "base index" refers to the index on the stack where we
2236// started compiling the pattern matching expression. These offsets from that
2237// base index indicate the location of the various locals we need.
2238#define PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE 0
2239#define PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING 1
2240#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P 2
2241#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE 3
2242#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY 4
2243
2244// A forward declaration because this is the recursive function that handles
2245// compiling a pattern. It can be reentered by nesting patterns, as in the case
2246// of arrays or hashes.
2247static int pm_compile_pattern(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *matched_label, LABEL *unmatched_label, bool in_single_pattern, bool in_alternation_pattern, bool use_deconstructed_cache, unsigned int base_index);
2248
2253static int
2254pm_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)
2255{
2256 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2257 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2258
2259 PUSH_INSN(ret, location, dup);
2260 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2261
2262 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2263 PUSH_INSN1(ret, location, putobject, message);
2264 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2265 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(2));
2266 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2267
2268 PUSH_INSN1(ret, location, putobject, Qfalse);
2269 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2270
2271 PUSH_INSN(ret, location, pop);
2272 PUSH_INSN(ret, location, pop);
2273 PUSH_LABEL(ret, match_succeeded_label);
2274
2275 return COMPILE_OK;
2276}
2277
2283static int
2284pm_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)
2285{
2286 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2287 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2288
2289 PUSH_INSN(ret, location, dup);
2290 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2291
2292 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2293 PUSH_INSN1(ret, location, putobject, message);
2294 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2295 PUSH_INSN(ret, location, dup);
2296 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2297 PUSH_INSN1(ret, location, putobject, length);
2298 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(4));
2299 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2300
2301 PUSH_INSN1(ret, location, putobject, Qfalse);
2302 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2303
2304 PUSH_INSN(ret, location, pop);
2305 PUSH_INSN(ret, location, pop);
2306 PUSH_LABEL(ret, match_succeeded_label);
2307
2308 return COMPILE_OK;
2309}
2310
2316static int
2317pm_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)
2318{
2319 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2320 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2321
2322 PUSH_INSN(ret, location, dup);
2323 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2324 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2325
2326 VALUE operand = rb_fstring_lit("%p === %p does not return true");
2327 PUSH_INSN1(ret, location, putobject, operand);
2328
2329 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2330 PUSH_INSN1(ret, location, topn, INT2FIX(5));
2331 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2332 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2333 PUSH_INSN1(ret, location, putobject, Qfalse);
2334 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2335 PUSH_INSN(ret, location, pop);
2336 PUSH_INSN(ret, location, pop);
2337
2338 PUSH_LABEL(ret, match_succeeded_label);
2339 PUSH_INSN1(ret, location, setn, INT2FIX(2));
2340 PUSH_INSN(ret, location, pop);
2341 PUSH_INSN(ret, location, pop);
2342
2343 return COMPILE_OK;
2344}
2345
2352static int
2353pm_compile_pattern_match(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *unmatched_label, bool in_single_pattern, bool in_alternation_pattern, bool use_deconstructed_cache, unsigned int base_index)
2354{
2355 LABEL *matched_label = NEW_LABEL(pm_node_line_number(scope_node->parser, node));
2356 CHECK(pm_compile_pattern(iseq, scope_node, node, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
2357 PUSH_LABEL(ret, matched_label);
2358 return COMPILE_OK;
2359}
2360
2366static int
2367pm_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)
2368{
2369 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2370
2371 if (use_deconstructed_cache) {
2372 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2373 PUSH_INSNL(ret, location, branchnil, deconstruct_label);
2374
2375 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2376 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2377
2378 PUSH_INSN(ret, location, pop);
2379 PUSH_INSN1(ret, location, topn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE - 1));
2380 PUSH_INSNL(ret, location, jump, deconstructed_label);
2381 }
2382 else {
2383 PUSH_INSNL(ret, location, jump, deconstruct_label);
2384 }
2385
2386 PUSH_LABEL(ret, deconstruct_label);
2387 PUSH_INSN(ret, location, dup);
2388
2389 VALUE operand = ID2SYM(rb_intern("deconstruct"));
2390 PUSH_INSN1(ret, location, putobject, operand);
2391 PUSH_SEND(ret, location, idRespond_to, INT2FIX(1));
2392
2393 if (use_deconstructed_cache) {
2394 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE + 1));
2395 }
2396
2397 if (in_single_pattern) {
2398 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p does not respond to #deconstruct"), base_index + 1));
2399 }
2400
2401 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2402 PUSH_SEND(ret, location, rb_intern("deconstruct"), INT2FIX(0));
2403
2404 if (use_deconstructed_cache) {
2405 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2406 }
2407
2408 PUSH_INSN(ret, location, dup);
2409 PUSH_INSN1(ret, location, checktype, INT2FIX(T_ARRAY));
2410 PUSH_INSNL(ret, location, branchunless, type_error_label);
2411 PUSH_LABEL(ret, deconstructed_label);
2412
2413 return COMPILE_OK;
2414}
2415
2420static int
2421pm_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)
2422{
2423 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2424
2425 PUSH_INSN(ret, location, dup);
2426 PM_COMPILE_NOT_POPPED(node);
2427
2428 if (in_single_pattern) {
2429 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
2430 }
2431 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE));
2432 if (in_single_pattern) {
2433 CHECK(pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 3));
2434 }
2435 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2436 return COMPILE_OK;
2437}
2438
2443static void
2444pm_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)
2445{
2446 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2447 LABEL *key_error_label = NEW_LABEL(location.line);
2448 LABEL *cleanup_label = NEW_LABEL(location.line);
2449
2450 struct rb_callinfo_kwarg *kw_arg = rb_xmalloc_mul_add(2, sizeof(VALUE), sizeof(struct rb_callinfo_kwarg));
2451 kw_arg->references = 0;
2452 kw_arg->keyword_len = 2;
2453 kw_arg->keywords[0] = ID2SYM(rb_intern("matchee"));
2454 kw_arg->keywords[1] = ID2SYM(rb_intern("key"));
2455
2456 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2457 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2458 PUSH_INSNL(ret, location, branchif, key_error_label);
2459
2460 PUSH_INSN1(ret, location, putobject, rb_eNoMatchingPatternError);
2461 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2462
2463 {
2464 VALUE operand = rb_fstring_lit("%p: %s");
2465 PUSH_INSN1(ret, location, putobject, operand);
2466 }
2467
2468 PUSH_INSN1(ret, location, topn, INT2FIX(4));
2469 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2470 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2471 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2472 PUSH_INSNL(ret, location, jump, cleanup_label);
2473
2474 PUSH_LABEL(ret, key_error_label);
2475 PUSH_INSN1(ret, location, putobject, rb_eNoMatchingPatternKeyError);
2476 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2477
2478 {
2479 VALUE operand = rb_fstring_lit("%p: %s");
2480 PUSH_INSN1(ret, location, putobject, operand);
2481 }
2482
2483 PUSH_INSN1(ret, location, topn, INT2FIX(4));
2484 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2485 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(3));
2486 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2487 PUSH_INSN1(ret, location, topn, INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2488 PUSH_SEND_R(ret, location, rb_intern("new"), INT2FIX(1), NULL, INT2FIX(VM_CALL_KWARG), kw_arg);
2489 PUSH_SEND(ret, location, id_core_raise, INT2FIX(1));
2490 PUSH_LABEL(ret, cleanup_label);
2491
2492 PUSH_INSN1(ret, location, adjuststack, INT2FIX(7));
2493 if (!popped) PUSH_INSN(ret, location, putnil);
2494 PUSH_INSNL(ret, location, jump, done_label);
2495 PUSH_INSN1(ret, location, dupn, INT2FIX(5));
2496 if (popped) PUSH_INSN(ret, location, putnil);
2497}
2498
2502static int
2503pm_compile_pattern(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_node_t *node, LINK_ANCHOR *const ret, LABEL *matched_label, LABEL *unmatched_label, bool in_single_pattern, bool in_alternation_pattern, bool use_deconstructed_cache, unsigned int base_index)
2504{
2505 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2506
2507 switch (PM_NODE_TYPE(node)) {
2508 case PM_ARRAY_PATTERN_NODE: {
2509 // Array patterns in pattern matching are triggered by using commas in
2510 // a pattern or wrapping it in braces. They are represented by a
2511 // ArrayPatternNode. This looks like:
2512 //
2513 // foo => [1, 2, 3]
2514 //
2515 // It can optionally have a splat in the middle of it, which can
2516 // optionally have a name attached.
2517 const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
2518
2519 const size_t requireds_size = cast->requireds.size;
2520 const size_t posts_size = cast->posts.size;
2521 const size_t minimum_size = requireds_size + posts_size;
2522
2523 bool rest_named = false;
2524 bool use_rest_size = false;
2525
2526 if (cast->rest != NULL) {
2527 rest_named = (PM_NODE_TYPE_P(cast->rest, PM_SPLAT_NODE) && ((const pm_splat_node_t *) cast->rest)->expression != NULL);
2528 use_rest_size = (rest_named || (!rest_named && posts_size > 0));
2529 }
2530
2531 LABEL *match_failed_label = NEW_LABEL(location.line);
2532 LABEL *type_error_label = NEW_LABEL(location.line);
2533 LABEL *deconstruct_label = NEW_LABEL(location.line);
2534 LABEL *deconstructed_label = NEW_LABEL(location.line);
2535
2536 if (use_rest_size) {
2537 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2538 PUSH_INSN(ret, location, swap);
2539 base_index++;
2540 }
2541
2542 if (cast->constant != NULL) {
2543 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2544 }
2545
2546 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));
2547
2548 PUSH_INSN(ret, location, dup);
2549 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2550 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2551 PUSH_SEND(ret, location, cast->rest == NULL ? idEq : idGE, INT2FIX(1));
2552 if (in_single_pattern) {
2553 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+)");
2554 CHECK(pm_compile_pattern_length_error(iseq, scope_node, node, ret, message, INT2FIX(minimum_size), base_index + 1));
2555 }
2556 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2557
2558 for (size_t index = 0; index < requireds_size; index++) {
2559 const pm_node_t *required = cast->requireds.nodes[index];
2560 PUSH_INSN(ret, location, dup);
2561 PUSH_INSN1(ret, location, putobject, INT2FIX(index));
2562 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2563 CHECK(pm_compile_pattern_match(iseq, scope_node, required, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2564 }
2565
2566 if (cast->rest != NULL) {
2567 if (rest_named) {
2568 PUSH_INSN(ret, location, dup);
2569 PUSH_INSN1(ret, location, putobject, INT2FIX(requireds_size));
2570 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2571 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2572 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2573 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2574 PUSH_INSN1(ret, location, setn, INT2FIX(4));
2575 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2576 CHECK(pm_compile_pattern_match(iseq, scope_node, ((const pm_splat_node_t *) cast->rest)->expression, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2577 }
2578 else if (posts_size > 0) {
2579 PUSH_INSN(ret, location, dup);
2580 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2581 PUSH_INSN1(ret, location, putobject, INT2FIX(minimum_size));
2582 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2583 PUSH_INSN1(ret, location, setn, INT2FIX(2));
2584 PUSH_INSN(ret, location, pop);
2585 }
2586 }
2587
2588 for (size_t index = 0; index < posts_size; index++) {
2589 const pm_node_t *post = cast->posts.nodes[index];
2590 PUSH_INSN(ret, location, dup);
2591
2592 PUSH_INSN1(ret, location, putobject, INT2FIX(requireds_size + index));
2593 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2594 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2595 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2596 CHECK(pm_compile_pattern_match(iseq, scope_node, post, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2597 }
2598
2599 PUSH_INSN(ret, location, pop);
2600 if (use_rest_size) {
2601 PUSH_INSN(ret, location, pop);
2602 }
2603
2604 PUSH_INSNL(ret, location, jump, matched_label);
2605 PUSH_INSN(ret, location, putnil);
2606 if (use_rest_size) {
2607 PUSH_INSN(ret, location, putnil);
2608 }
2609
2610 PUSH_LABEL(ret, type_error_label);
2611 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2612 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2613
2614 {
2615 VALUE operand = rb_fstring_lit("deconstruct must return Array");
2616 PUSH_INSN1(ret, location, putobject, operand);
2617 }
2618
2619 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2620 PUSH_INSN(ret, location, pop);
2621
2622 PUSH_LABEL(ret, match_failed_label);
2623 PUSH_INSN(ret, location, pop);
2624 if (use_rest_size) {
2625 PUSH_INSN(ret, location, pop);
2626 }
2627
2628 PUSH_INSNL(ret, location, jump, unmatched_label);
2629 break;
2630 }
2631 case PM_FIND_PATTERN_NODE: {
2632 // Find patterns in pattern matching are triggered by using commas in
2633 // a pattern or wrapping it in braces and using a splat on both the left
2634 // and right side of the pattern. This looks like:
2635 //
2636 // foo => [*, 1, 2, 3, *]
2637 //
2638 // There can be any number of requireds in the middle. The splats on
2639 // both sides can optionally have names attached.
2640 const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
2641 const size_t size = cast->requireds.size;
2642
2643 LABEL *match_failed_label = NEW_LABEL(location.line);
2644 LABEL *type_error_label = NEW_LABEL(location.line);
2645 LABEL *deconstruct_label = NEW_LABEL(location.line);
2646 LABEL *deconstructed_label = NEW_LABEL(location.line);
2647
2648 if (cast->constant) {
2649 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2650 }
2651
2652 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));
2653
2654 PUSH_INSN(ret, location, dup);
2655 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2656 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2657 PUSH_SEND(ret, location, idGE, INT2FIX(1));
2658 if (in_single_pattern) {
2659 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));
2660 }
2661 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2662
2663 {
2664 LABEL *while_begin_label = NEW_LABEL(location.line);
2665 LABEL *next_loop_label = NEW_LABEL(location.line);
2666 LABEL *find_succeeded_label = NEW_LABEL(location.line);
2667 LABEL *find_failed_label = NEW_LABEL(location.line);
2668
2669 PUSH_INSN(ret, location, dup);
2670 PUSH_SEND(ret, location, idLength, INT2FIX(0));
2671
2672 PUSH_INSN(ret, location, dup);
2673 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2674 PUSH_SEND(ret, location, idMINUS, INT2FIX(1));
2675 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2676 PUSH_LABEL(ret, while_begin_label);
2677
2678 PUSH_INSN(ret, location, dup);
2679 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2680 PUSH_SEND(ret, location, idLE, INT2FIX(1));
2681 PUSH_INSNL(ret, location, branchunless, find_failed_label);
2682
2683 for (size_t index = 0; index < size; index++) {
2684 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2685 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2686
2687 if (index != 0) {
2688 PUSH_INSN1(ret, location, putobject, INT2FIX(index));
2689 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2690 }
2691
2692 PUSH_SEND(ret, location, idAREF, INT2FIX(1));
2693 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->requireds.nodes[index], ret, next_loop_label, in_single_pattern, in_alternation_pattern, false, base_index + 4));
2694 }
2695
2696 const pm_splat_node_t *left = cast->left;
2697
2698 if (left->expression != NULL) {
2699 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2700 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
2701 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2702 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2703 CHECK(pm_compile_pattern_match(iseq, scope_node, left->expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 4));
2704 }
2705
2706 RUBY_ASSERT(PM_NODE_TYPE_P(cast->right, PM_SPLAT_NODE));
2707 const pm_splat_node_t *right = (const pm_splat_node_t *) cast->right;
2708
2709 if (right->expression != NULL) {
2710 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2711 PUSH_INSN1(ret, location, topn, INT2FIX(1));
2712 PUSH_INSN1(ret, location, putobject, INT2FIX(size));
2713 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2714 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2715 PUSH_SEND(ret, location, idAREF, INT2FIX(2));
2716 pm_compile_pattern_match(iseq, scope_node, right->expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 4);
2717 }
2718
2719 PUSH_INSNL(ret, location, jump, find_succeeded_label);
2720
2721 PUSH_LABEL(ret, next_loop_label);
2722 PUSH_INSN1(ret, location, putobject, INT2FIX(1));
2723 PUSH_SEND(ret, location, idPLUS, INT2FIX(1));
2724 PUSH_INSNL(ret, location, jump, while_begin_label);
2725
2726 PUSH_LABEL(ret, find_failed_label);
2727 PUSH_INSN1(ret, location, adjuststack, INT2FIX(3));
2728 if (in_single_pattern) {
2729 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2730
2731 {
2732 VALUE operand = rb_fstring_lit("%p does not match to find pattern");
2733 PUSH_INSN1(ret, location, putobject, operand);
2734 }
2735
2736 PUSH_INSN1(ret, location, topn, INT2FIX(2));
2737 PUSH_SEND(ret, location, id_core_sprintf, INT2FIX(2));
2738 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2739
2740 PUSH_INSN1(ret, location, putobject, Qfalse);
2741 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2742
2743 PUSH_INSN(ret, location, pop);
2744 PUSH_INSN(ret, location, pop);
2745 }
2746 PUSH_INSNL(ret, location, jump, match_failed_label);
2747 PUSH_INSN1(ret, location, dupn, INT2FIX(3));
2748
2749 PUSH_LABEL(ret, find_succeeded_label);
2750 PUSH_INSN1(ret, location, adjuststack, INT2FIX(3));
2751 }
2752
2753 PUSH_INSN(ret, location, pop);
2754 PUSH_INSNL(ret, location, jump, matched_label);
2755 PUSH_INSN(ret, location, putnil);
2756
2757 PUSH_LABEL(ret, type_error_label);
2758 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2759 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2760
2761 {
2762 VALUE operand = rb_fstring_lit("deconstruct must return Array");
2763 PUSH_INSN1(ret, location, putobject, operand);
2764 }
2765
2766 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2767 PUSH_INSN(ret, location, pop);
2768
2769 PUSH_LABEL(ret, match_failed_label);
2770 PUSH_INSN(ret, location, pop);
2771 PUSH_INSNL(ret, location, jump, unmatched_label);
2772
2773 break;
2774 }
2775 case PM_HASH_PATTERN_NODE: {
2776 // Hash patterns in pattern matching are triggered by using labels and
2777 // values in a pattern or by using the ** operator. They are represented
2778 // by the HashPatternNode. This looks like:
2779 //
2780 // foo => { a: 1, b: 2, **bar }
2781 //
2782 // It can optionally have an assoc splat in the middle of it, which can
2783 // optionally have a name.
2784 const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
2785
2786 // We don't consider it a "rest" parameter if it's a ** that is unnamed.
2787 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);
2788 bool has_keys = cast->elements.size > 0 || cast->rest != NULL;
2789
2790 LABEL *match_failed_label = NEW_LABEL(location.line);
2791 LABEL *type_error_label = NEW_LABEL(location.line);
2792 VALUE keys = Qnil;
2793
2794 if (has_keys && !has_rest) {
2795 keys = rb_ary_new_capa(cast->elements.size);
2796
2797 for (size_t index = 0; index < cast->elements.size; index++) {
2798 const pm_node_t *element = cast->elements.nodes[index];
2799 RUBY_ASSERT(PM_NODE_TYPE_P(element, PM_ASSOC_NODE));
2800
2801 const pm_node_t *key = ((const pm_assoc_node_t *) element)->key;
2802 RUBY_ASSERT(PM_NODE_TYPE_P(key, PM_SYMBOL_NODE));
2803
2804 VALUE symbol = ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) key));
2805 rb_ary_push(keys, symbol);
2806 }
2807 }
2808
2809 if (cast->constant) {
2810 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->constant, ret, match_failed_label, in_single_pattern, base_index));
2811 }
2812
2813 PUSH_INSN(ret, location, dup);
2814
2815 {
2816 VALUE operand = ID2SYM(rb_intern("deconstruct_keys"));
2817 PUSH_INSN1(ret, location, putobject, operand);
2818 }
2819
2820 PUSH_SEND(ret, location, idRespond_to, INT2FIX(1));
2821 if (in_single_pattern) {
2822 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p does not respond to #deconstruct_keys"), base_index + 1));
2823 }
2824 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2825
2826 if (NIL_P(keys)) {
2827 PUSH_INSN(ret, location, putnil);
2828 }
2829 else {
2830 PUSH_INSN1(ret, location, duparray, keys);
2831 RB_OBJ_WRITTEN(iseq, Qundef, rb_obj_hide(keys));
2832 }
2833 PUSH_SEND(ret, location, rb_intern("deconstruct_keys"), INT2FIX(1));
2834
2835 PUSH_INSN(ret, location, dup);
2836 PUSH_INSN1(ret, location, checktype, INT2FIX(T_HASH));
2837 PUSH_INSNL(ret, location, branchunless, type_error_label);
2838
2839 if (has_rest) {
2840 PUSH_SEND(ret, location, rb_intern("dup"), INT2FIX(0));
2841 }
2842
2843 if (has_keys) {
2844 DECL_ANCHOR(match_values);
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_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
2851 const pm_node_t *key = assoc->key;
2852 RUBY_ASSERT(PM_NODE_TYPE_P(key, PM_SYMBOL_NODE));
2853
2854 VALUE symbol = ID2SYM(parse_string_symbol(scope_node, (const pm_symbol_node_t *) key));
2855 PUSH_INSN(ret, location, dup);
2856 PUSH_INSN1(ret, location, putobject, symbol);
2857 PUSH_SEND(ret, location, rb_intern("key?"), INT2FIX(1));
2858
2859 if (in_single_pattern) {
2860 LABEL *match_succeeded_label = NEW_LABEL(location.line);
2861
2862 PUSH_INSN(ret, location, dup);
2863 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2864
2865 {
2866 VALUE operand = rb_str_freeze(rb_sprintf("key not found: %+"PRIsVALUE, symbol));
2867 PUSH_INSN1(ret, location, putobject, operand);
2868 }
2869
2870 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 2));
2871 PUSH_INSN1(ret, location, putobject, Qtrue);
2872 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 3));
2873 PUSH_INSN1(ret, location, topn, INT2FIX(3));
2874 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2875 PUSH_INSN1(ret, location, putobject, symbol);
2876 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2877
2878 PUSH_INSN1(ret, location, adjuststack, INT2FIX(4));
2879 PUSH_LABEL(ret, match_succeeded_label);
2880 }
2881
2882 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2883 PUSH_INSN(match_values, location, dup);
2884 PUSH_INSN1(match_values, location, putobject, symbol);
2885 PUSH_SEND(match_values, location, has_rest ? rb_intern("delete") : idAREF, INT2FIX(1));
2886
2887 const pm_node_t *value = assoc->value;
2888 if (PM_NODE_TYPE_P(value, PM_IMPLICIT_NODE)) {
2889 value = ((const pm_implicit_node_t *) value)->value;
2890 }
2891
2892 CHECK(pm_compile_pattern_match(iseq, scope_node, value, match_values, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1));
2893 }
2894
2895 PUSH_SEQ(ret, match_values);
2896 }
2897 else {
2898 PUSH_INSN(ret, location, dup);
2899 PUSH_SEND(ret, location, idEmptyP, INT2FIX(0));
2900 if (in_single_pattern) {
2901 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("%p is not empty"), base_index + 1));
2902 }
2903 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2904 }
2905
2906 if (has_rest) {
2907 switch (PM_NODE_TYPE(cast->rest)) {
2908 case PM_NO_KEYWORDS_PARAMETER_NODE: {
2909 PUSH_INSN(ret, location, dup);
2910 PUSH_SEND(ret, location, idEmptyP, INT2FIX(0));
2911 if (in_single_pattern) {
2912 pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit("rest of %p is not empty"), base_index + 1);
2913 }
2914 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2915 break;
2916 }
2917 case PM_ASSOC_SPLAT_NODE: {
2918 const pm_assoc_splat_node_t *splat = (const pm_assoc_splat_node_t *) cast->rest;
2919 PUSH_INSN(ret, location, dup);
2920 pm_compile_pattern_match(iseq, scope_node, splat->value, ret, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index + 1);
2921 break;
2922 }
2923 default:
2924 rb_bug("unreachable");
2925 break;
2926 }
2927 }
2928
2929 PUSH_INSN(ret, location, pop);
2930 PUSH_INSNL(ret, location, jump, matched_label);
2931 PUSH_INSN(ret, location, putnil);
2932
2933 PUSH_LABEL(ret, type_error_label);
2934 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2935 PUSH_INSN1(ret, location, putobject, rb_eTypeError);
2936
2937 {
2938 VALUE operand = rb_fstring_lit("deconstruct_keys must return Hash");
2939 PUSH_INSN1(ret, location, putobject, operand);
2940 }
2941
2942 PUSH_SEND(ret, location, id_core_raise, INT2FIX(2));
2943 PUSH_INSN(ret, location, pop);
2944
2945 PUSH_LABEL(ret, match_failed_label);
2946 PUSH_INSN(ret, location, pop);
2947 PUSH_INSNL(ret, location, jump, unmatched_label);
2948 break;
2949 }
2950 case PM_CAPTURE_PATTERN_NODE: {
2951 // Capture patterns allow you to pattern match against an element in a
2952 // pattern and also capture the value into a local variable. This looks
2953 // like:
2954 //
2955 // [1] => [Integer => foo]
2956 //
2957 // In this case the `Integer => foo` will be represented by a
2958 // CapturePatternNode, which has both a value (the pattern to match
2959 // against) and a target (the place to write the variable into).
2960 const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
2961
2962 LABEL *match_failed_label = NEW_LABEL(location.line);
2963
2964 PUSH_INSN(ret, location, dup);
2965 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->value, ret, match_failed_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index + 1));
2966 CHECK(pm_compile_pattern(iseq, scope_node, (const pm_node_t *) cast->target, ret, matched_label, match_failed_label, in_single_pattern, in_alternation_pattern, false, base_index));
2967 PUSH_INSN(ret, location, putnil);
2968
2969 PUSH_LABEL(ret, match_failed_label);
2970 PUSH_INSN(ret, location, pop);
2971 PUSH_INSNL(ret, location, jump, unmatched_label);
2972
2973 break;
2974 }
2975 case PM_LOCAL_VARIABLE_TARGET_NODE: {
2976 // Local variables can be targeted by placing identifiers in the place
2977 // of a pattern. For example, foo in bar. This results in the value
2978 // being matched being written to that local variable.
2979 const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
2980 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
2981
2982 // If this local variable is being written from within an alternation
2983 // pattern, then it cannot actually be added to the local table since
2984 // it's ambiguous which value should be used. So instead we indicate
2985 // this with a compile error.
2986 if (in_alternation_pattern) {
2987 ID id = pm_constant_id_lookup(scope_node, cast->name);
2988 const char *name = rb_id2name(id);
2989
2990 if (name && strlen(name) > 0 && name[0] != '_') {
2991 COMPILE_ERROR(iseq, location.line, "illegal variable in alternative pattern (%"PRIsVALUE")", rb_id2str(id));
2992 return COMPILE_NG;
2993 }
2994 }
2995
2996 PUSH_SETLOCAL(ret, location, index.index, index.level);
2997 PUSH_INSNL(ret, location, jump, matched_label);
2998 break;
2999 }
3000 case PM_ALTERNATION_PATTERN_NODE: {
3001 // Alternation patterns allow you to specify multiple patterns in a
3002 // single expression using the | operator.
3003 const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
3004
3005 LABEL *matched_left_label = NEW_LABEL(location.line);
3006 LABEL *unmatched_left_label = NEW_LABEL(location.line);
3007
3008 // First, we're going to attempt to match against the left pattern. If
3009 // that pattern matches, then we'll skip matching the right pattern.
3010 PUSH_INSN(ret, location, dup);
3011 CHECK(pm_compile_pattern(iseq, scope_node, cast->left, ret, matched_left_label, unmatched_left_label, in_single_pattern, true, use_deconstructed_cache, base_index + 1));
3012
3013 // If we get here, then we matched on the left pattern. In this case we
3014 // should pop out the duplicate value that we preemptively added to
3015 // match against the right pattern and then jump to the match label.
3016 PUSH_LABEL(ret, matched_left_label);
3017 PUSH_INSN(ret, location, pop);
3018 PUSH_INSNL(ret, location, jump, matched_label);
3019 PUSH_INSN(ret, location, putnil);
3020
3021 // If we get here, then we didn't match on the left pattern. In this
3022 // case we attempt to match against the right pattern.
3023 PUSH_LABEL(ret, unmatched_left_label);
3024 CHECK(pm_compile_pattern(iseq, scope_node, cast->right, ret, matched_label, unmatched_label, in_single_pattern, true, use_deconstructed_cache, base_index));
3025 break;
3026 }
3027 case PM_PARENTHESES_NODE:
3028 // Parentheses are allowed to wrap expressions in pattern matching and
3029 // they do nothing since they can only wrap individual expressions and
3030 // not groups. In this case we'll recurse back into this same function
3031 // with the body of the parentheses.
3032 return pm_compile_pattern(iseq, scope_node, ((const pm_parentheses_node_t *) node)->body, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index);
3033 case PM_PINNED_EXPRESSION_NODE:
3034 // Pinned expressions are a way to match against the value of an
3035 // expression that should be evaluated at runtime. This looks like:
3036 // foo in ^(bar). To compile these, we compile the expression as if it
3037 // were a literal value by falling through to the literal case.
3038 node = ((const pm_pinned_expression_node_t *) node)->expression;
3039 /* fallthrough */
3040 case PM_ARRAY_NODE:
3041 case PM_CLASS_VARIABLE_READ_NODE:
3042 case PM_CONSTANT_PATH_NODE:
3043 case PM_CONSTANT_READ_NODE:
3044 case PM_FALSE_NODE:
3045 case PM_FLOAT_NODE:
3046 case PM_GLOBAL_VARIABLE_READ_NODE:
3047 case PM_IMAGINARY_NODE:
3048 case PM_INSTANCE_VARIABLE_READ_NODE:
3049 case PM_IT_LOCAL_VARIABLE_READ_NODE:
3050 case PM_INTEGER_NODE:
3051 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
3052 case PM_INTERPOLATED_STRING_NODE:
3053 case PM_INTERPOLATED_SYMBOL_NODE:
3054 case PM_INTERPOLATED_X_STRING_NODE:
3055 case PM_LAMBDA_NODE:
3056 case PM_LOCAL_VARIABLE_READ_NODE:
3057 case PM_NIL_NODE:
3058 case PM_SOURCE_ENCODING_NODE:
3059 case PM_SOURCE_FILE_NODE:
3060 case PM_SOURCE_LINE_NODE:
3061 case PM_RANGE_NODE:
3062 case PM_RATIONAL_NODE:
3063 case PM_REGULAR_EXPRESSION_NODE:
3064 case PM_SELF_NODE:
3065 case PM_STRING_NODE:
3066 case PM_SYMBOL_NODE:
3067 case PM_TRUE_NODE:
3068 case PM_X_STRING_NODE: {
3069 // These nodes are all simple patterns, which means we'll use the
3070 // checkmatch instruction to match against them, which is effectively a
3071 // VM-level === operator.
3072 PM_COMPILE_NOT_POPPED(node);
3073 if (in_single_pattern) {
3074 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
3075 }
3076
3077 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE));
3078
3079 if (in_single_pattern) {
3080 pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 2);
3081 }
3082
3083 PUSH_INSNL(ret, location, branchif, matched_label);
3084 PUSH_INSNL(ret, location, jump, unmatched_label);
3085 break;
3086 }
3087 case PM_PINNED_VARIABLE_NODE: {
3088 // Pinned variables are a way to match against the value of a variable
3089 // without it looking like you're trying to write to the variable. This
3090 // looks like: foo in ^@bar. To compile these, we compile the variable
3091 // that they hold.
3092 const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
3093 CHECK(pm_compile_pattern(iseq, scope_node, cast->variable, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, true, base_index));
3094 break;
3095 }
3096 case PM_IF_NODE:
3097 case PM_UNLESS_NODE: {
3098 // If and unless nodes can show up here as guards on `in` clauses. This
3099 // looks like:
3100 //
3101 // case foo
3102 // in bar if baz?
3103 // qux
3104 // end
3105 //
3106 // Because we know they're in the modifier form and they can't have any
3107 // variation on this pattern, we compile them differently (more simply)
3108 // here than we would in the normal compilation path.
3109 const pm_node_t *predicate;
3110 const pm_node_t *statement;
3111
3112 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3113 const pm_if_node_t *cast = (const pm_if_node_t *) node;
3114 predicate = cast->predicate;
3115
3116 RUBY_ASSERT(cast->statements != NULL && cast->statements->body.size == 1);
3117 statement = cast->statements->body.nodes[0];
3118 }
3119 else {
3120 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
3121 predicate = cast->predicate;
3122
3123 RUBY_ASSERT(cast->statements != NULL && cast->statements->body.size == 1);
3124 statement = cast->statements->body.nodes[0];
3125 }
3126
3127 CHECK(pm_compile_pattern_match(iseq, scope_node, statement, ret, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
3128 PM_COMPILE_NOT_POPPED(predicate);
3129
3130 if (in_single_pattern) {
3131 LABEL *match_succeeded_label = NEW_LABEL(location.line);
3132
3133 PUSH_INSN(ret, location, dup);
3134 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3135 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
3136 }
3137 else {
3138 PUSH_INSNL(ret, location, branchunless, match_succeeded_label);
3139 }
3140
3141 {
3142 VALUE operand = rb_fstring_lit("guard clause does not return true");
3143 PUSH_INSN1(ret, location, putobject, operand);
3144 }
3145
3146 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
3147 PUSH_INSN1(ret, location, putobject, Qfalse);
3148 PUSH_INSN1(ret, location, setn, INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
3149
3150 PUSH_INSN(ret, location, pop);
3151 PUSH_INSN(ret, location, pop);
3152
3153 PUSH_LABEL(ret, match_succeeded_label);
3154 }
3155
3156 if (PM_NODE_TYPE_P(node, PM_IF_NODE)) {
3157 PUSH_INSNL(ret, location, branchunless, unmatched_label);
3158 }
3159 else {
3160 PUSH_INSNL(ret, location, branchif, unmatched_label);
3161 }
3162
3163 PUSH_INSNL(ret, location, jump, matched_label);
3164 break;
3165 }
3166 default:
3167 // If we get here, then we have a node type that should not be in this
3168 // position. This would be a bug in the parser, because a different node
3169 // type should never have been created in this position in the tree.
3170 rb_bug("Unexpected node type in pattern matching expression: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
3171 break;
3172 }
3173
3174 return COMPILE_OK;
3175}
3176
3177#undef PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE
3178#undef PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING
3179#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P
3180#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE
3181#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY
3182
3183// Generate a scope node from the given node.
3184void
3185pm_scope_node_init(const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_t *previous)
3186{
3187 // This is very important, otherwise the scope node could be seen as having
3188 // certain flags set that _should not_ be set.
3189 memset(scope, 0, sizeof(pm_scope_node_t));
3190
3191 scope->base.type = PM_SCOPE_NODE;
3192 scope->base.location.start = node->location.start;
3193 scope->base.location.end = node->location.end;
3194
3195 scope->previous = previous;
3196 scope->ast_node = (pm_node_t *) node;
3197
3198 if (previous) {
3199 scope->parser = previous->parser;
3200 scope->encoding = previous->encoding;
3201 scope->filepath_encoding = previous->filepath_encoding;
3202 scope->constants = previous->constants;
3203 scope->coverage_enabled = previous->coverage_enabled;
3204 scope->script_lines = previous->script_lines;
3205 }
3206
3207 switch (PM_NODE_TYPE(node)) {
3208 case PM_BLOCK_NODE: {
3209 const pm_block_node_t *cast = (const pm_block_node_t *) node;
3210 scope->body = cast->body;
3211 scope->locals = cast->locals;
3212 scope->parameters = cast->parameters;
3213 break;
3214 }
3215 case PM_CLASS_NODE: {
3216 const pm_class_node_t *cast = (const pm_class_node_t *) node;
3217 scope->body = cast->body;
3218 scope->locals = cast->locals;
3219 break;
3220 }
3221 case PM_DEF_NODE: {
3222 const pm_def_node_t *cast = (const pm_def_node_t *) node;
3223 scope->parameters = (pm_node_t *) cast->parameters;
3224 scope->body = cast->body;
3225 scope->locals = cast->locals;
3226 break;
3227 }
3228 case PM_ENSURE_NODE: {
3229 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
3230 scope->body = (pm_node_t *) node;
3231
3232 if (cast->statements != NULL) {
3233 scope->base.location.start = cast->statements->base.location.start;
3234 scope->base.location.end = cast->statements->base.location.end;
3235 }
3236
3237 break;
3238 }
3239 case PM_FOR_NODE: {
3240 const pm_for_node_t *cast = (const pm_for_node_t *) node;
3241 scope->body = (pm_node_t *) cast->statements;
3242 break;
3243 }
3244 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
3245 RUBY_ASSERT(node->flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE);
3246 scope->body = (pm_node_t *) node;
3247 break;
3248 }
3249 case PM_LAMBDA_NODE: {
3250 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
3251 scope->parameters = cast->parameters;
3252 scope->body = cast->body;
3253 scope->locals = cast->locals;
3254
3255 if (cast->parameters != NULL) {
3256 scope->base.location.start = cast->parameters->location.start;
3257 }
3258 else {
3259 scope->base.location.start = cast->operator_loc.end;
3260 }
3261 break;
3262 }
3263 case PM_MODULE_NODE: {
3264 const pm_module_node_t *cast = (const pm_module_node_t *) node;
3265 scope->body = cast->body;
3266 scope->locals = cast->locals;
3267 break;
3268 }
3269 case PM_POST_EXECUTION_NODE: {
3270 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
3271 scope->body = (pm_node_t *) cast->statements;
3272 break;
3273 }
3274 case PM_PROGRAM_NODE: {
3275 const pm_program_node_t *cast = (const pm_program_node_t *) node;
3276 scope->body = (pm_node_t *) cast->statements;
3277 scope->locals = cast->locals;
3278 break;
3279 }
3280 case PM_RESCUE_NODE: {
3281 const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
3282 scope->body = (pm_node_t *) cast->statements;
3283 break;
3284 }
3285 case PM_RESCUE_MODIFIER_NODE: {
3286 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
3287 scope->body = (pm_node_t *) cast->rescue_expression;
3288 break;
3289 }
3290 case PM_SINGLETON_CLASS_NODE: {
3291 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
3292 scope->body = cast->body;
3293 scope->locals = cast->locals;
3294 break;
3295 }
3296 case PM_STATEMENTS_NODE: {
3297 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
3298 scope->body = (pm_node_t *) cast;
3299 break;
3300 }
3301 default:
3302 rb_bug("unreachable");
3303 break;
3304 }
3305}
3306
3307void
3308pm_scope_node_destroy(pm_scope_node_t *scope_node)
3309{
3310 if (scope_node->index_lookup_table) {
3311 st_free_table(scope_node->index_lookup_table);
3312 }
3313}
3314
3326static void
3327pm_compile_retry_end_label(rb_iseq_t *iseq, LINK_ANCHOR *const ret, LABEL *retry_end_l)
3328{
3329 INSN *iobj;
3330 LINK_ELEMENT *last_elem = LAST_ELEMENT(ret);
3331 iobj = IS_INSN(last_elem) ? (INSN*) last_elem : (INSN*) get_prev_insn((INSN*) last_elem);
3332 while (!IS_INSN_ID(iobj, send) && !IS_INSN_ID(iobj, invokesuper) && !IS_INSN_ID(iobj, sendforward) && !IS_INSN_ID(iobj, invokesuperforward)) {
3333 iobj = (INSN*) get_prev_insn(iobj);
3334 }
3335 ELEM_INSERT_NEXT(&iobj->link, (LINK_ELEMENT*) retry_end_l);
3336
3337 // LINK_ANCHOR has a pointer to the last element, but
3338 // ELEM_INSERT_NEXT does not update it even if we add an insn to the
3339 // last of LINK_ANCHOR. So this updates it manually.
3340 if (&iobj->link == LAST_ELEMENT(ret)) {
3341 ret->last = (LINK_ELEMENT*) retry_end_l;
3342 }
3343}
3344
3345static const char *
3346pm_iseq_builtin_function_name(const pm_scope_node_t *scope_node, const pm_node_t *receiver, ID method_id)
3347{
3348 const char *name = rb_id2name(method_id);
3349 static const char prefix[] = "__builtin_";
3350 const size_t prefix_len = sizeof(prefix) - 1;
3351
3352 if (receiver == NULL) {
3353 if (UNLIKELY(strncmp(prefix, name, prefix_len) == 0)) {
3354 // __builtin_foo
3355 return &name[prefix_len];
3356 }
3357 }
3358 else if (PM_NODE_TYPE_P(receiver, PM_CALL_NODE)) {
3359 if (PM_NODE_FLAG_P(receiver, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3360 const pm_call_node_t *cast = (const pm_call_node_t *) receiver;
3361 if (pm_constant_id_lookup(scope_node, cast->name) == rb_intern_const("__builtin")) {
3362 // __builtin.foo
3363 return name;
3364 }
3365 }
3366 }
3367 else if (PM_NODE_TYPE_P(receiver, PM_CONSTANT_READ_NODE)) {
3368 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) receiver;
3369 if (pm_constant_id_lookup(scope_node, cast->name) == rb_intern_const("Primitive")) {
3370 // Primitive.foo
3371 return name;
3372 }
3373 }
3374
3375 return NULL;
3376}
3377
3378// Compile Primitive.attr! :leaf, ...
3379static int
3380pm_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)
3381{
3382 if (arguments == NULL) {
3383 COMPILE_ERROR(iseq, node_location->line, "attr!: no argument");
3384 return COMPILE_NG;
3385 }
3386
3387 const pm_node_t *argument;
3388 PM_NODE_LIST_FOREACH(&arguments->arguments, index, argument) {
3389 if (!PM_NODE_TYPE_P(argument, PM_SYMBOL_NODE)) {
3390 COMPILE_ERROR(iseq, node_location->line, "non symbol argument to attr!: %s", pm_node_type_to_str(PM_NODE_TYPE(argument)));
3391 return COMPILE_NG;
3392 }
3393
3394 VALUE symbol = pm_static_literal_value(iseq, argument, scope_node);
3395 VALUE string = rb_sym2str(symbol);
3396
3397 if (strcmp(RSTRING_PTR(string), "leaf") == 0) {
3398 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_LEAF;
3399 }
3400 else if (strcmp(RSTRING_PTR(string), "inline_block") == 0) {
3401 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_INLINE_BLOCK;
3402 }
3403 else if (strcmp(RSTRING_PTR(string), "use_block") == 0) {
3404 iseq_set_use_block(iseq);
3405 }
3406 else if (strcmp(RSTRING_PTR(string), "c_trace") == 0) {
3407 // Let the iseq act like a C method in backtraces
3408 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_C_TRACE;
3409 }
3410 else {
3411 COMPILE_ERROR(iseq, node_location->line, "unknown argument to attr!: %s", RSTRING_PTR(string));
3412 return COMPILE_NG;
3413 }
3414 }
3415
3416 return COMPILE_OK;
3417}
3418
3419static int
3420pm_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)
3421{
3422 if (arguments == NULL) {
3423 COMPILE_ERROR(iseq, node_location->line, "arg!: no argument");
3424 return COMPILE_NG;
3425 }
3426
3427 if (arguments->arguments.size != 1) {
3428 COMPILE_ERROR(iseq, node_location->line, "arg!: too many argument");
3429 return COMPILE_NG;
3430 }
3431
3432 const pm_node_t *argument = arguments->arguments.nodes[0];
3433 if (!PM_NODE_TYPE_P(argument, PM_SYMBOL_NODE)) {
3434 COMPILE_ERROR(iseq, node_location->line, "non symbol argument to arg!: %s", pm_node_type_to_str(PM_NODE_TYPE(argument)));
3435 return COMPILE_NG;
3436 }
3437
3438 if (!popped) {
3439 ID name = parse_string_symbol(scope_node, ((const pm_symbol_node_t *) argument));
3440 int index = ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->local_table_size - get_local_var_idx(iseq, name);
3441
3442 debugs("id: %s idx: %d\n", rb_id2name(name), index);
3443 PUSH_GETLOCAL(ret, *node_location, index, get_lvar_level(iseq));
3444 }
3445
3446 return COMPILE_OK;
3447}
3448
3449static int
3450pm_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)
3451{
3452 const pm_node_t *ast_node = scope_node->ast_node;
3453 if (!PM_NODE_TYPE_P(ast_node, PM_DEF_NODE)) {
3454 rb_bug("mandatory_only?: not in method definition");
3455 return COMPILE_NG;
3456 }
3457
3458 const pm_def_node_t *def_node = (const pm_def_node_t *) ast_node;
3459 const pm_parameters_node_t *parameters_node = def_node->parameters;
3460 if (parameters_node == NULL) {
3461 rb_bug("mandatory_only?: in method definition with no parameters");
3462 return COMPILE_NG;
3463 }
3464
3465 const pm_node_t *body_node = def_node->body;
3466 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)) {
3467 rb_bug("mandatory_only?: not in method definition with plain statements");
3468 return COMPILE_NG;
3469 }
3470
3471 const pm_if_node_t *if_node = (const pm_if_node_t *) ((const pm_statements_node_t *) body_node)->body.nodes[0];
3472 if (if_node->predicate != ((const pm_node_t *) call_node)) {
3473 rb_bug("mandatory_only?: can't find mandatory node");
3474 return COMPILE_NG;
3475 }
3476
3477 pm_parameters_node_t parameters = {
3478 .base = parameters_node->base,
3479 .requireds = parameters_node->requireds
3480 };
3481
3482 const pm_def_node_t def = {
3483 .base = def_node->base,
3484 .name = def_node->name,
3485 .receiver = def_node->receiver,
3486 .parameters = &parameters,
3487 .body = (pm_node_t *) if_node->statements,
3488 .locals = {
3489 .ids = def_node->locals.ids,
3490 .size = parameters_node->requireds.size,
3491 .capacity = def_node->locals.capacity
3492 }
3493 };
3494
3495 pm_scope_node_t next_scope_node;
3496 pm_scope_node_init(&def.base, &next_scope_node, scope_node);
3497
3498 int error_state;
3499 ISEQ_BODY(iseq)->mandatory_only_iseq = pm_iseq_new_with_opt(
3500 &next_scope_node,
3501 rb_iseq_base_label(iseq),
3502 rb_iseq_path(iseq),
3503 rb_iseq_realpath(iseq),
3504 node_location->line,
3505 NULL,
3506 0,
3507 ISEQ_TYPE_METHOD,
3508 ISEQ_COMPILE_DATA(iseq)->option,
3509 &error_state
3510 );
3511
3512 if (error_state) {
3513 RUBY_ASSERT(ISEQ_BODY(iseq)->mandatory_only_iseq == NULL);
3514 rb_jump_tag(error_state);
3515 }
3516
3517 pm_scope_node_destroy(&next_scope_node);
3518 return COMPILE_OK;
3519}
3520
3521static int
3522pm_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)
3523{
3524 const pm_arguments_node_t *arguments = call_node->arguments;
3525
3526 if (parent_block != NULL) {
3527 COMPILE_ERROR(iseq, node_location->line, "should not call builtins here.");
3528 return COMPILE_NG;
3529 }
3530
3531#define BUILTIN_INLINE_PREFIX "_bi"
3532 char inline_func[sizeof(BUILTIN_INLINE_PREFIX) + DECIMAL_SIZE_OF(int)];
3533 bool cconst = false;
3534retry:;
3535 const struct rb_builtin_function *bf = iseq_builtin_function_lookup(iseq, builtin_func);
3536
3537 if (bf == NULL) {
3538 if (strcmp("cstmt!", builtin_func) == 0 || strcmp("cexpr!", builtin_func) == 0) {
3539 // ok
3540 }
3541 else if (strcmp("cconst!", builtin_func) == 0) {
3542 cconst = true;
3543 }
3544 else if (strcmp("cinit!", builtin_func) == 0) {
3545 // ignore
3546 return COMPILE_OK;
3547 }
3548 else if (strcmp("attr!", builtin_func) == 0) {
3549 return pm_compile_builtin_attr(iseq, scope_node, arguments, node_location);
3550 }
3551 else if (strcmp("arg!", builtin_func) == 0) {
3552 return pm_compile_builtin_arg(iseq, ret, scope_node, arguments, node_location, popped);
3553 }
3554 else if (strcmp("mandatory_only?", builtin_func) == 0) {
3555 if (popped) {
3556 rb_bug("mandatory_only? should be in if condition");
3557 }
3558 else if (!LIST_INSN_SIZE_ZERO(ret)) {
3559 rb_bug("mandatory_only? should be put on top");
3560 }
3561
3562 PUSH_INSN1(ret, *node_location, putobject, Qfalse);
3563 return pm_compile_builtin_mandatory_only_method(iseq, scope_node, call_node, node_location);
3564 }
3565 else if (1) {
3566 rb_bug("can't find builtin function:%s", builtin_func);
3567 }
3568 else {
3569 COMPILE_ERROR(iseq, node_location->line, "can't find builtin function:%s", builtin_func);
3570 return COMPILE_NG;
3571 }
3572
3573 int inline_index = node_location->line;
3574 snprintf(inline_func, sizeof(inline_func), BUILTIN_INLINE_PREFIX "%d", inline_index);
3575 builtin_func = inline_func;
3576 arguments = NULL;
3577 goto retry;
3578 }
3579
3580 if (cconst) {
3581 typedef VALUE(*builtin_func0)(void *, VALUE);
3582 VALUE const_val = (*(builtin_func0)(uintptr_t)bf->func_ptr)(NULL, Qnil);
3583 PUSH_INSN1(ret, *node_location, putobject, const_val);
3584 return COMPILE_OK;
3585 }
3586
3587 // fprintf(stderr, "func_name:%s -> %p\n", builtin_func, bf->func_ptr);
3588
3589 DECL_ANCHOR(args_seq);
3590
3591 int flags = 0;
3592 struct rb_callinfo_kwarg *keywords = NULL;
3593 int argc = pm_setup_args(arguments, call_node->block, &flags, &keywords, iseq, args_seq, scope_node, node_location);
3594
3595 if (argc != bf->argc) {
3596 COMPILE_ERROR(iseq, node_location->line, "argc is not match for builtin function:%s (expect %d but %d)", builtin_func, bf->argc, argc);
3597 return COMPILE_NG;
3598 }
3599
3600 unsigned int start_index;
3601 if (delegate_call_p(iseq, argc, args_seq, &start_index)) {
3602 PUSH_INSN2(ret, *node_location, opt_invokebuiltin_delegate, bf, INT2FIX(start_index));
3603 }
3604 else {
3605 PUSH_SEQ(ret, args_seq);
3606 PUSH_INSN1(ret, *node_location, invokebuiltin, bf);
3607 }
3608
3609 if (popped) PUSH_INSN(ret, *node_location, pop);
3610 return COMPILE_OK;
3611}
3612
3616static void
3617pm_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)
3618{
3619 const pm_location_t *message_loc = &call_node->message_loc;
3620 if (message_loc->start == NULL) message_loc = &call_node->base.location;
3621
3622 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, message_loc, call_node->base.node_id);
3623 LABEL *else_label = NEW_LABEL(location.line);
3624 LABEL *end_label = NEW_LABEL(location.line);
3625 LABEL *retry_end_l = NEW_LABEL(location.line);
3626
3627 VALUE branches = Qfalse;
3628 rb_code_location_t code_location = { 0 };
3629 int node_id = location.node_id;
3630
3631 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3632 if (PM_BRANCH_COVERAGE_P(iseq)) {
3633 const uint8_t *cursors[3] = {
3634 call_node->closing_loc.end,
3635 call_node->arguments == NULL ? NULL : call_node->arguments->base.location.end,
3636 call_node->message_loc.end
3637 };
3638
3639 const uint8_t *end_cursor = cursors[0];
3640 end_cursor = (end_cursor == NULL || cursors[1] == NULL) ? cursors[1] : (end_cursor > cursors[1] ? end_cursor : cursors[1]);
3641 end_cursor = (end_cursor == NULL || cursors[2] == NULL) ? cursors[2] : (end_cursor > cursors[2] ? end_cursor : cursors[2]);
3642 if (!end_cursor) end_cursor = call_node->closing_loc.end;
3643
3644 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, call_node);
3645 const pm_line_column_t end_location = pm_newline_list_line_column(&scope_node->parser->newline_list, end_cursor, scope_node->parser->start_line);
3646
3647 code_location = (rb_code_location_t) {
3648 .beg_pos = { .lineno = start_location.line, .column = start_location.column },
3649 .end_pos = { .lineno = end_location.line, .column = end_location.column }
3650 };
3651
3652 branches = decl_branch_base(iseq, PTR2NUM(call_node), &code_location, "&.");
3653 }
3654
3655 PUSH_INSN(ret, location, dup);
3656 PUSH_INSNL(ret, location, branchnil, else_label);
3657
3658 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 0, "then", branches);
3659 }
3660
3661 int flags = 0;
3662 struct rb_callinfo_kwarg *kw_arg = NULL;
3663
3664 int orig_argc = pm_setup_args(call_node->arguments, call_node->block, &flags, &kw_arg, iseq, ret, scope_node, &location);
3665 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
3666 const rb_iseq_t *block_iseq = NULL;
3667
3668 if (call_node->block != NULL && PM_NODE_TYPE_P(call_node->block, PM_BLOCK_NODE)) {
3669 // Scope associated with the block
3670 pm_scope_node_t next_scope_node;
3671 pm_scope_node_init(call_node->block, &next_scope_node, scope_node);
3672
3673 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));
3674 pm_scope_node_destroy(&next_scope_node);
3675 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
3676 }
3677 else {
3678 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3679 flags |= VM_CALL_VCALL;
3680 }
3681
3682 if (!flags) {
3683 flags |= VM_CALL_ARGS_SIMPLE;
3684 }
3685 }
3686
3687 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3688 flags |= VM_CALL_FCALL;
3689 }
3690
3691 if (!popped && PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3692 if (flags & VM_CALL_ARGS_BLOCKARG) {
3693 PUSH_INSN1(ret, location, topn, INT2FIX(1));
3694 if (flags & VM_CALL_ARGS_SPLAT) {
3695 PUSH_INSN1(ret, location, putobject, INT2FIX(-1));
3696 PUSH_SEND_WITH_FLAG(ret, location, idAREF, INT2FIX(1), INT2FIX(0));
3697 }
3698 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 3));
3699 PUSH_INSN(ret, location, pop);
3700 }
3701 else if (flags & VM_CALL_ARGS_SPLAT) {
3702 PUSH_INSN(ret, location, dup);
3703 PUSH_INSN1(ret, location, putobject, INT2FIX(-1));
3704 PUSH_SEND_WITH_FLAG(ret, location, idAREF, INT2FIX(1), INT2FIX(0));
3705 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 2));
3706 PUSH_INSN(ret, location, pop);
3707 }
3708 else {
3709 PUSH_INSN1(ret, location, setn, INT2FIX(orig_argc + 1));
3710 }
3711 }
3712
3713 if ((flags & VM_CALL_KW_SPLAT) && (flags & VM_CALL_ARGS_BLOCKARG) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
3714 PUSH_INSN(ret, location, splatkw);
3715 }
3716
3717 PUSH_SEND_R(ret, location, method_id, INT2FIX(orig_argc), block_iseq, INT2FIX(flags), kw_arg);
3718
3719 if (block_iseq && ISEQ_BODY(block_iseq)->catch_table) {
3720 pm_compile_retry_end_label(iseq, ret, retry_end_l);
3721 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, start, retry_end_l, block_iseq, retry_end_l);
3722 }
3723
3724 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3725 PUSH_INSNL(ret, location, jump, end_label);
3726 PUSH_LABEL(ret, else_label);
3727 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 1, "else", branches);
3728 PUSH_LABEL(ret, end_label);
3729 }
3730
3731 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) && !popped) {
3732 PUSH_INSN(ret, location, pop);
3733 }
3734
3735 if (popped) PUSH_INSN(ret, location, pop);
3736 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
3737}
3738
3743static inline VALUE
3744pm_compile_back_reference_ref(const pm_back_reference_read_node_t *node)
3745{
3746 const char *type = (const char *) (node->base.location.start + 1);
3747
3748 // Since a back reference is `$<char>`, Ruby represents the ID as an
3749 // rb_intern on the value after the `$`.
3750 return INT2FIX(rb_intern2(type, 1)) << 1 | 1;
3751}
3752
3757static inline VALUE
3758pm_compile_numbered_reference_ref(const pm_numbered_reference_read_node_t *node)
3759{
3760 return INT2FIX(node->number << 1);
3761}
3762
3763static void
3764pm_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)
3765{
3766#define PUSH_VAL(type) (in_condition ? Qtrue : rb_iseq_defined_string(type))
3767
3768 // in_condition is the same as compile.c's needstr
3769 enum defined_type dtype = DEFINED_NOT_DEFINED;
3770 const pm_node_location_t location = *node_location;
3771
3772 switch (PM_NODE_TYPE(node)) {
3773/* DEFINED_NIL ****************************************************************/
3774 case PM_NIL_NODE:
3775 // defined?(nil)
3776 // ^^^
3777 dtype = DEFINED_NIL;
3778 break;
3779/* DEFINED_IVAR ***************************************************************/
3780 case PM_INSTANCE_VARIABLE_READ_NODE: {
3781 // defined?(@a)
3782 // ^^
3783 const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
3784 ID name = pm_constant_id_lookup(scope_node, cast->name);
3785
3786 PUSH_INSN3(ret, location, definedivar, ID2SYM(name), get_ivar_ic_value(iseq, name), PUSH_VAL(DEFINED_IVAR));
3787
3788 return;
3789 }
3790/* DEFINED_LVAR ***************************************************************/
3791 case PM_LOCAL_VARIABLE_READ_NODE:
3792 // a = 1; defined?(a)
3793 // ^
3794 case PM_IT_LOCAL_VARIABLE_READ_NODE:
3795 // 1.then { defined?(it) }
3796 // ^^
3797 dtype = DEFINED_LVAR;
3798 break;
3799/* DEFINED_GVAR ***************************************************************/
3800 case PM_GLOBAL_VARIABLE_READ_NODE: {
3801 // defined?($a)
3802 // ^^
3803 const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
3804 ID name = pm_constant_id_lookup(scope_node, cast->name);
3805
3806 PUSH_INSN(ret, location, putnil);
3807 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_GVAR), ID2SYM(name), PUSH_VAL(DEFINED_GVAR));
3808
3809 return;
3810 }
3811/* DEFINED_CVAR ***************************************************************/
3812 case PM_CLASS_VARIABLE_READ_NODE: {
3813 // defined?(@@a)
3814 // ^^^
3815 const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
3816 ID name = pm_constant_id_lookup(scope_node, cast->name);
3817
3818 PUSH_INSN(ret, location, putnil);
3819 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CVAR), ID2SYM(name), PUSH_VAL(DEFINED_CVAR));
3820
3821 return;
3822 }
3823/* DEFINED_CONST **************************************************************/
3824 case PM_CONSTANT_READ_NODE: {
3825 // defined?(A)
3826 // ^
3827 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
3828 ID name = pm_constant_id_lookup(scope_node, cast->name);
3829
3830 PUSH_INSN(ret, location, putnil);
3831 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST), ID2SYM(name), PUSH_VAL(DEFINED_CONST));
3832
3833 return;
3834 }
3835/* DEFINED_YIELD **************************************************************/
3836 case PM_YIELD_NODE:
3837 // defined?(yield)
3838 // ^^^^^
3839 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
3840
3841 PUSH_INSN(ret, location, putnil);
3842 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_YIELD), 0, PUSH_VAL(DEFINED_YIELD));
3843
3844 return;
3845/* DEFINED_ZSUPER *************************************************************/
3846 case PM_SUPER_NODE: {
3847 // defined?(super 1, 2)
3848 // ^^^^^^^^^^
3849 const pm_super_node_t *cast = (const pm_super_node_t *) node;
3850
3851 if (cast->block != NULL && !PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE)) {
3852 dtype = DEFINED_EXPR;
3853 break;
3854 }
3855
3856 PUSH_INSN(ret, location, putnil);
3857 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3858 return;
3859 }
3860 case PM_FORWARDING_SUPER_NODE: {
3861 // defined?(super)
3862 // ^^^^^
3863 const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
3864
3865 if (cast->block != NULL) {
3866 dtype = DEFINED_EXPR;
3867 break;
3868 }
3869
3870 PUSH_INSN(ret, location, putnil);
3871 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3872 return;
3873 }
3874/* DEFINED_SELF ***************************************************************/
3875 case PM_SELF_NODE:
3876 // defined?(self)
3877 // ^^^^
3878 dtype = DEFINED_SELF;
3879 break;
3880/* DEFINED_TRUE ***************************************************************/
3881 case PM_TRUE_NODE:
3882 // defined?(true)
3883 // ^^^^
3884 dtype = DEFINED_TRUE;
3885 break;
3886/* DEFINED_FALSE **************************************************************/
3887 case PM_FALSE_NODE:
3888 // defined?(false)
3889 // ^^^^^
3890 dtype = DEFINED_FALSE;
3891 break;
3892/* DEFINED_ASGN ***************************************************************/
3893 case PM_CALL_AND_WRITE_NODE:
3894 // defined?(a.a &&= 1)
3895 // ^^^^^^^^^
3896 case PM_CALL_OPERATOR_WRITE_NODE:
3897 // defined?(a.a += 1)
3898 // ^^^^^^^^
3899 case PM_CALL_OR_WRITE_NODE:
3900 // defined?(a.a ||= 1)
3901 // ^^^^^^^^^
3902 case PM_CLASS_VARIABLE_AND_WRITE_NODE:
3903 // defined?(@@a &&= 1)
3904 // ^^^^^^^^^
3905 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
3906 // defined?(@@a += 1)
3907 // ^^^^^^^^
3908 case PM_CLASS_VARIABLE_OR_WRITE_NODE:
3909 // defined?(@@a ||= 1)
3910 // ^^^^^^^^^
3911 case PM_CLASS_VARIABLE_WRITE_NODE:
3912 // defined?(@@a = 1)
3913 // ^^^^^^^
3914 case PM_CONSTANT_AND_WRITE_NODE:
3915 // defined?(A &&= 1)
3916 // ^^^^^^^
3917 case PM_CONSTANT_OPERATOR_WRITE_NODE:
3918 // defined?(A += 1)
3919 // ^^^^^^
3920 case PM_CONSTANT_OR_WRITE_NODE:
3921 // defined?(A ||= 1)
3922 // ^^^^^^^
3923 case PM_CONSTANT_PATH_AND_WRITE_NODE:
3924 // defined?(A::A &&= 1)
3925 // ^^^^^^^^^^
3926 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE:
3927 // defined?(A::A += 1)
3928 // ^^^^^^^^^
3929 case PM_CONSTANT_PATH_OR_WRITE_NODE:
3930 // defined?(A::A ||= 1)
3931 // ^^^^^^^^^^
3932 case PM_CONSTANT_PATH_WRITE_NODE:
3933 // defined?(A::A = 1)
3934 // ^^^^^^^^
3935 case PM_CONSTANT_WRITE_NODE:
3936 // defined?(A = 1)
3937 // ^^^^^
3938 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE:
3939 // defined?($a &&= 1)
3940 // ^^^^^^^^
3941 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
3942 // defined?($a += 1)
3943 // ^^^^^^^
3944 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE:
3945 // defined?($a ||= 1)
3946 // ^^^^^^^^
3947 case PM_GLOBAL_VARIABLE_WRITE_NODE:
3948 // defined?($a = 1)
3949 // ^^^^^^
3950 case PM_INDEX_AND_WRITE_NODE:
3951 // defined?(a[1] &&= 1)
3952 // ^^^^^^^^^^
3953 case PM_INDEX_OPERATOR_WRITE_NODE:
3954 // defined?(a[1] += 1)
3955 // ^^^^^^^^^
3956 case PM_INDEX_OR_WRITE_NODE:
3957 // defined?(a[1] ||= 1)
3958 // ^^^^^^^^^^
3959 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE:
3960 // defined?(@a &&= 1)
3961 // ^^^^^^^^
3962 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
3963 // defined?(@a += 1)
3964 // ^^^^^^^
3965 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE:
3966 // defined?(@a ||= 1)
3967 // ^^^^^^^^
3968 case PM_INSTANCE_VARIABLE_WRITE_NODE:
3969 // defined?(@a = 1)
3970 // ^^^^^^
3971 case PM_LOCAL_VARIABLE_AND_WRITE_NODE:
3972 // defined?(a &&= 1)
3973 // ^^^^^^^
3974 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
3975 // defined?(a += 1)
3976 // ^^^^^^
3977 case PM_LOCAL_VARIABLE_OR_WRITE_NODE:
3978 // defined?(a ||= 1)
3979 // ^^^^^^^
3980 case PM_LOCAL_VARIABLE_WRITE_NODE:
3981 // defined?(a = 1)
3982 // ^^^^^
3983 case PM_MULTI_WRITE_NODE:
3984 // defined?((a, = 1))
3985 // ^^^^^^
3986 dtype = DEFINED_ASGN;
3987 break;
3988/* DEFINED_EXPR ***************************************************************/
3989 case PM_ALIAS_GLOBAL_VARIABLE_NODE:
3990 // defined?((alias $a $b))
3991 // ^^^^^^^^^^^
3992 case PM_ALIAS_METHOD_NODE:
3993 // defined?((alias a b))
3994 // ^^^^^^^^^
3995 case PM_AND_NODE:
3996 // defined?(a and b)
3997 // ^^^^^^^
3998 case PM_BREAK_NODE:
3999 // defined?(break 1)
4000 // ^^^^^^^
4001 case PM_CASE_MATCH_NODE:
4002 // defined?(case 1; in 1; end)
4003 // ^^^^^^^^^^^^^^^^^
4004 case PM_CASE_NODE:
4005 // defined?(case 1; when 1; end)
4006 // ^^^^^^^^^^^^^^^^^^^
4007 case PM_CLASS_NODE:
4008 // defined?(class Foo; end)
4009 // ^^^^^^^^^^^^^^
4010 case PM_DEF_NODE:
4011 // defined?(def a() end)
4012 // ^^^^^^^^^^^
4013 case PM_DEFINED_NODE:
4014 // defined?(defined?(a))
4015 // ^^^^^^^^^^^
4016 case PM_FLIP_FLOP_NODE:
4017 // defined?(not (a .. b))
4018 // ^^^^^^
4019 case PM_FLOAT_NODE:
4020 // defined?(1.0)
4021 // ^^^
4022 case PM_FOR_NODE:
4023 // defined?(for a in 1 do end)
4024 // ^^^^^^^^^^^^^^^^^
4025 case PM_IF_NODE:
4026 // defined?(if a then end)
4027 // ^^^^^^^^^^^^^
4028 case PM_IMAGINARY_NODE:
4029 // defined?(1i)
4030 // ^^
4031 case PM_INTEGER_NODE:
4032 // defined?(1)
4033 // ^
4034 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE:
4035 // defined?(not /#{1}/)
4036 // ^^^^^^
4037 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
4038 // defined?(/#{1}/)
4039 // ^^^^^^
4040 case PM_INTERPOLATED_STRING_NODE:
4041 // defined?("#{1}")
4042 // ^^^^^^
4043 case PM_INTERPOLATED_SYMBOL_NODE:
4044 // defined?(:"#{1}")
4045 // ^^^^^^^
4046 case PM_INTERPOLATED_X_STRING_NODE:
4047 // defined?(`#{1}`)
4048 // ^^^^^^
4049 case PM_LAMBDA_NODE:
4050 // defined?(-> {})
4051 // ^^^^^
4052 case PM_MATCH_LAST_LINE_NODE:
4053 // defined?(not //)
4054 // ^^^^^^
4055 case PM_MATCH_PREDICATE_NODE:
4056 // defined?(1 in 1)
4057 // ^^^^^^
4058 case PM_MATCH_REQUIRED_NODE:
4059 // defined?(1 => 1)
4060 // ^^^^^^
4061 case PM_MATCH_WRITE_NODE:
4062 // defined?(/(?<a>)/ =~ "")
4063 // ^^^^^^^^^^^^^^
4064 case PM_MODULE_NODE:
4065 // defined?(module A end)
4066 // ^^^^^^^^^^^^
4067 case PM_NEXT_NODE:
4068 // defined?(next 1)
4069 // ^^^^^^
4070 case PM_OR_NODE:
4071 // defined?(a or b)
4072 // ^^^^^^
4073 case PM_POST_EXECUTION_NODE:
4074 // defined?((END {}))
4075 // ^^^^^^^^
4076 case PM_RANGE_NODE:
4077 // defined?(1..1)
4078 // ^^^^
4079 case PM_RATIONAL_NODE:
4080 // defined?(1r)
4081 // ^^
4082 case PM_REDO_NODE:
4083 // defined?(redo)
4084 // ^^^^
4085 case PM_REGULAR_EXPRESSION_NODE:
4086 // defined?(//)
4087 // ^^
4088 case PM_RESCUE_MODIFIER_NODE:
4089 // defined?(a rescue b)
4090 // ^^^^^^^^^^
4091 case PM_RETRY_NODE:
4092 // defined?(retry)
4093 // ^^^^^
4094 case PM_RETURN_NODE:
4095 // defined?(return)
4096 // ^^^^^^
4097 case PM_SINGLETON_CLASS_NODE:
4098 // defined?(class << self; end)
4099 // ^^^^^^^^^^^^^^^^^^
4100 case PM_SOURCE_ENCODING_NODE:
4101 // defined?(__ENCODING__)
4102 // ^^^^^^^^^^^^
4103 case PM_SOURCE_FILE_NODE:
4104 // defined?(__FILE__)
4105 // ^^^^^^^^
4106 case PM_SOURCE_LINE_NODE:
4107 // defined?(__LINE__)
4108 // ^^^^^^^^
4109 case PM_STRING_NODE:
4110 // defined?("")
4111 // ^^
4112 case PM_SYMBOL_NODE:
4113 // defined?(:a)
4114 // ^^
4115 case PM_UNDEF_NODE:
4116 // defined?((undef a))
4117 // ^^^^^^^
4118 case PM_UNLESS_NODE:
4119 // defined?(unless a then end)
4120 // ^^^^^^^^^^^^^^^^^
4121 case PM_UNTIL_NODE:
4122 // defined?(until a do end)
4123 // ^^^^^^^^^^^^^^
4124 case PM_WHILE_NODE:
4125 // defined?(while a do end)
4126 // ^^^^^^^^^^^^^^
4127 case PM_X_STRING_NODE:
4128 // defined?(``)
4129 // ^^
4130 dtype = DEFINED_EXPR;
4131 break;
4132/* DEFINED_REF ****************************************************************/
4133 case PM_BACK_REFERENCE_READ_NODE: {
4134 // defined?($+)
4135 // ^^
4136 const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
4137 VALUE ref = pm_compile_back_reference_ref(cast);
4138
4139 PUSH_INSN(ret, location, putnil);
4140 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4141
4142 return;
4143 }
4144 case PM_NUMBERED_REFERENCE_READ_NODE: {
4145 // defined?($1)
4146 // ^^
4147 const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
4148 VALUE ref = pm_compile_numbered_reference_ref(cast);
4149
4150 PUSH_INSN(ret, location, putnil);
4151 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4152
4153 return;
4154 }
4155/* DEFINED_CONST_FROM *********************************************************/
4156 case PM_CONSTANT_PATH_NODE: {
4157 // defined?(A::A)
4158 // ^^^^
4159 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
4160 ID name = pm_constant_id_lookup(scope_node, cast->name);
4161
4162 if (cast->parent != NULL) {
4163 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4164 pm_compile_defined_expr0(iseq, cast->parent, node_location, ret, popped, scope_node, true, lfinish, false);
4165
4166 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4167 PM_COMPILE(cast->parent);
4168 }
4169 else {
4170 PUSH_INSN1(ret, location, putobject, rb_cObject);
4171 }
4172
4173 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST_FROM), ID2SYM(name), PUSH_VAL(DEFINED_CONST));
4174 return;
4175 }
4176/* Containers *****************************************************************/
4177 case PM_BEGIN_NODE: {
4178 // defined?(begin end)
4179 // ^^^^^^^^^
4180 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
4181
4182 if (cast->rescue_clause == NULL && cast->ensure_clause == NULL && cast->else_clause == NULL) {
4183 if (cast->statements == NULL) {
4184 // If we have empty statements, then we want to return "nil".
4185 dtype = DEFINED_NIL;
4186 }
4187 else if (cast->statements->body.size == 1) {
4188 // If we have a begin node that is wrapping a single statement
4189 // then we want to recurse down to that statement and compile
4190 // it.
4191 pm_compile_defined_expr0(iseq, cast->statements->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish, false);
4192 return;
4193 }
4194 else {
4195 // Otherwise, we have a begin wrapping multiple statements, in
4196 // which case this is defined as "expression".
4197 dtype = DEFINED_EXPR;
4198 }
4199 } else {
4200 // If we have any of the other clauses besides the main begin/end,
4201 // this is defined as "expression".
4202 dtype = DEFINED_EXPR;
4203 }
4204
4205 break;
4206 }
4207 case PM_PARENTHESES_NODE: {
4208 // defined?(())
4209 // ^^
4210 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
4211
4212 if (cast->body == NULL) {
4213 // If we have empty parentheses, then we want to return "nil".
4214 dtype = DEFINED_NIL;
4215 }
4216 else if (PM_NODE_TYPE_P(cast->body, PM_STATEMENTS_NODE) && ((const pm_statements_node_t *) cast->body)->body.size == 1) {
4217 // If we have a parentheses node that is wrapping a single statement
4218 // then we want to recurse down to that statement and compile it.
4219 pm_compile_defined_expr0(iseq, ((const pm_statements_node_t *) cast->body)->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4220 return;
4221 }
4222 else {
4223 // Otherwise, we have parentheses wrapping multiple statements, in
4224 // which case this is defined as "expression".
4225 dtype = DEFINED_EXPR;
4226 }
4227
4228 break;
4229 }
4230 case PM_ARRAY_NODE: {
4231 // defined?([])
4232 // ^^
4233 const pm_array_node_t *cast = (const pm_array_node_t *) node;
4234
4235 if (cast->elements.size > 0 && !lfinish[1]) {
4236 lfinish[1] = NEW_LABEL(location.line);
4237 }
4238
4239 for (size_t index = 0; index < cast->elements.size; index++) {
4240 pm_compile_defined_expr0(iseq, cast->elements.nodes[index], node_location, ret, popped, scope_node, true, lfinish, false);
4241 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4242 }
4243
4244 dtype = DEFINED_EXPR;
4245 break;
4246 }
4247 case PM_HASH_NODE:
4248 // defined?({ a: 1 })
4249 // ^^^^^^^^
4250 case PM_KEYWORD_HASH_NODE: {
4251 // defined?(a(a: 1))
4252 // ^^^^
4253 const pm_node_list_t *elements;
4254
4255 if (PM_NODE_TYPE_P(node, PM_HASH_NODE)) {
4256 elements = &((const pm_hash_node_t *) node)->elements;
4257 }
4258 else {
4259 elements = &((const pm_keyword_hash_node_t *) node)->elements;
4260 }
4261
4262 if (elements->size > 0 && !lfinish[1]) {
4263 lfinish[1] = NEW_LABEL(location.line);
4264 }
4265
4266 for (size_t index = 0; index < elements->size; index++) {
4267 pm_compile_defined_expr0(iseq, elements->nodes[index], node_location, ret, popped, scope_node, true, lfinish, false);
4268 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4269 }
4270
4271 dtype = DEFINED_EXPR;
4272 break;
4273 }
4274 case PM_ASSOC_NODE: {
4275 // defined?({ a: 1 })
4276 // ^^^^
4277 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
4278
4279 pm_compile_defined_expr0(iseq, cast->key, node_location, ret, popped, scope_node, true, lfinish, false);
4280 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4281 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, true, lfinish, false);
4282
4283 return;
4284 }
4285 case PM_ASSOC_SPLAT_NODE: {
4286 // defined?({ **a })
4287 // ^^^^
4288 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
4289
4290 if (cast->value == NULL) {
4291 dtype = DEFINED_EXPR;
4292 break;
4293 }
4294
4295 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, true, lfinish, false);
4296 return;
4297 }
4298 case PM_IMPLICIT_NODE: {
4299 // defined?({ a: })
4300 // ^^
4301 const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
4302 pm_compile_defined_expr0(iseq, cast->value, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4303 return;
4304 }
4305 case PM_CALL_NODE: {
4306#define BLOCK_P(cast) ((cast)->block != NULL && PM_NODE_TYPE_P((cast)->block, PM_BLOCK_NODE))
4307
4308 // defined?(a(1, 2, 3))
4309 // ^^^^^^^^^^
4310 const pm_call_node_t *cast = ((const pm_call_node_t *) node);
4311
4312 if (cast->block != NULL && PM_NODE_TYPE_P(cast->block, PM_BLOCK_NODE)) {
4313 dtype = DEFINED_EXPR;
4314 break;
4315 }
4316
4317 if (cast->receiver || cast->arguments || (cast->block && PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE))) {
4318 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4319 if (!lfinish[2]) lfinish[2] = NEW_LABEL(location.line);
4320 }
4321
4322 if (cast->arguments) {
4323 pm_compile_defined_expr0(iseq, (const pm_node_t *) cast->arguments, node_location, ret, popped, scope_node, true, lfinish, false);
4324 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4325 }
4326
4327 if (cast->block && PM_NODE_TYPE_P(cast->block, PM_BLOCK_ARGUMENT_NODE)) {
4328 pm_compile_defined_expr0(iseq, cast->block, node_location, ret, popped, scope_node, true, lfinish, false);
4329 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4330 }
4331
4332 if (cast->receiver) {
4333 if (PM_NODE_TYPE_P(cast->receiver, PM_CALL_NODE) && !BLOCK_P((const pm_call_node_t *) cast->receiver)) {
4334 // Special behavior here where we chain calls together. This is
4335 // the only path that sets explicit_receiver to true.
4336 pm_compile_defined_expr0(iseq, cast->receiver, node_location, ret, popped, scope_node, true, lfinish, true);
4337 PUSH_INSNL(ret, location, branchunless, lfinish[2]);
4338
4339 const pm_call_node_t *receiver = (const pm_call_node_t *) cast->receiver;
4340 ID method_id = pm_constant_id_lookup(scope_node, receiver->name);
4341
4342 pm_compile_call(iseq, receiver, ret, popped, scope_node, method_id, NULL);
4343 }
4344 else {
4345 pm_compile_defined_expr0(iseq, cast->receiver, node_location, ret, popped, scope_node, true, lfinish, false);
4346 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4347 PM_COMPILE(cast->receiver);
4348 }
4349
4350 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
4351
4352 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4353 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_METHOD), rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4354 }
4355 else {
4356 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
4357
4358 PUSH_INSN(ret, location, putself);
4359 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4360
4361 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_FUNC), rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4362 }
4363
4364 return;
4365 }
4366 case PM_ARGUMENTS_NODE: {
4367 // defined?(a(1, 2, 3))
4368 // ^^^^^^^
4369 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
4370
4371 for (size_t index = 0; index < cast->arguments.size; index++) {
4372 pm_compile_defined_expr0(iseq, cast->arguments.nodes[index], node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4373
4374 if (!lfinish[1]) {
4375 lfinish[1] = NEW_LABEL(location.line);
4376 }
4377 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4378 }
4379
4380 dtype = DEFINED_TRUE;
4381 break;
4382 }
4383 case PM_BLOCK_ARGUMENT_NODE:
4384 // defined?(a(&b))
4385 // ^^
4386 dtype = DEFINED_EXPR;
4387 break;
4388 case PM_FORWARDING_ARGUMENTS_NODE:
4389 // def a(...) = defined?(a(...))
4390 // ^^^
4391 dtype = DEFINED_EXPR;
4392 break;
4393 case PM_SPLAT_NODE: {
4394 // def a(*) = defined?(a(*))
4395 // ^
4396 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
4397
4398 if (cast->expression == NULL) {
4399 dtype = DEFINED_EXPR;
4400 break;
4401 }
4402
4403 pm_compile_defined_expr0(iseq, cast->expression, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4404
4405 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.line);
4406 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4407
4408 dtype = DEFINED_EXPR;
4409 break;
4410 }
4411 case PM_SHAREABLE_CONSTANT_NODE:
4412 // # shareable_constant_value: literal
4413 // defined?(A = 1)
4414 // ^^^^^
4415 pm_compile_defined_expr0(iseq, ((const pm_shareable_constant_node_t *) node)->write, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4416 return;
4417/* Unreachable (parameters) ***************************************************/
4418 case PM_BLOCK_LOCAL_VARIABLE_NODE:
4419 case PM_BLOCK_PARAMETER_NODE:
4420 case PM_BLOCK_PARAMETERS_NODE:
4421 case PM_FORWARDING_PARAMETER_NODE:
4422 case PM_IMPLICIT_REST_NODE:
4423 case PM_IT_PARAMETERS_NODE:
4424 case PM_PARAMETERS_NODE:
4425 case PM_KEYWORD_REST_PARAMETER_NODE:
4426 case PM_NO_KEYWORDS_PARAMETER_NODE:
4427 case PM_NUMBERED_PARAMETERS_NODE:
4428 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
4429 case PM_OPTIONAL_PARAMETER_NODE:
4430 case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
4431 case PM_REQUIRED_PARAMETER_NODE:
4432 case PM_REST_PARAMETER_NODE:
4433/* Unreachable (pattern matching) *********************************************/
4434 case PM_ALTERNATION_PATTERN_NODE:
4435 case PM_ARRAY_PATTERN_NODE:
4436 case PM_CAPTURE_PATTERN_NODE:
4437 case PM_FIND_PATTERN_NODE:
4438 case PM_HASH_PATTERN_NODE:
4439 case PM_PINNED_EXPRESSION_NODE:
4440 case PM_PINNED_VARIABLE_NODE:
4441/* Unreachable (indirect writes) **********************************************/
4442 case PM_CALL_TARGET_NODE:
4443 case PM_CLASS_VARIABLE_TARGET_NODE:
4444 case PM_CONSTANT_PATH_TARGET_NODE:
4445 case PM_CONSTANT_TARGET_NODE:
4446 case PM_GLOBAL_VARIABLE_TARGET_NODE:
4447 case PM_INDEX_TARGET_NODE:
4448 case PM_INSTANCE_VARIABLE_TARGET_NODE:
4449 case PM_LOCAL_VARIABLE_TARGET_NODE:
4450 case PM_MULTI_TARGET_NODE:
4451/* Unreachable (clauses) ******************************************************/
4452 case PM_ELSE_NODE:
4453 case PM_ENSURE_NODE:
4454 case PM_IN_NODE:
4455 case PM_RESCUE_NODE:
4456 case PM_WHEN_NODE:
4457/* Unreachable (miscellaneous) ************************************************/
4458 case PM_BLOCK_NODE:
4459 case PM_EMBEDDED_STATEMENTS_NODE:
4460 case PM_EMBEDDED_VARIABLE_NODE:
4461 case PM_MISSING_NODE:
4462 case PM_PRE_EXECUTION_NODE:
4463 case PM_PROGRAM_NODE:
4464 case PM_SCOPE_NODE:
4465 case PM_STATEMENTS_NODE:
4466 rb_bug("Unreachable node in defined?: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
4467 }
4468
4469 RUBY_ASSERT(dtype != DEFINED_NOT_DEFINED);
4470 PUSH_INSN1(ret, location, putobject, PUSH_VAL(dtype));
4471
4472#undef PUSH_VAL
4473}
4474
4475static void
4476pm_defined_expr(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_location_t *node_location, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node, bool in_condition, LABEL **lfinish, bool explicit_receiver)
4477{
4478 LINK_ELEMENT *lcur = ret->last;
4479 pm_compile_defined_expr0(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4480
4481 if (lfinish[1]) {
4482 LABEL *lstart = NEW_LABEL(node_location->line);
4483 LABEL *lend = NEW_LABEL(node_location->line);
4484
4485 struct rb_iseq_new_with_callback_callback_func *ifunc =
4486 rb_iseq_new_with_callback_new_callback(build_defined_rescue_iseq, NULL);
4487
4488 const rb_iseq_t *rescue = new_child_iseq_with_callback(
4489 iseq,
4490 ifunc,
4491 rb_str_concat(rb_str_new2("defined guard in "), ISEQ_BODY(iseq)->location.label),
4492 iseq,
4493 ISEQ_TYPE_RESCUE,
4494 0
4495 );
4496
4497 lstart->rescued = LABEL_RESCUE_BEG;
4498 lend->rescued = LABEL_RESCUE_END;
4499
4500 APPEND_LABEL(ret, lcur, lstart);
4501 PUSH_LABEL(ret, lend);
4502 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lfinish[1]);
4503 }
4504}
4505
4506static void
4507pm_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)
4508{
4509 LABEL *lfinish[3];
4510 LINK_ELEMENT *last = ret->last;
4511
4512 lfinish[0] = NEW_LABEL(node_location->line);
4513 lfinish[1] = 0;
4514 lfinish[2] = 0;
4515
4516 if (!popped) {
4517 pm_defined_expr(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish, false);
4518 }
4519
4520 if (lfinish[1]) {
4521 ELEM_INSERT_NEXT(last, &new_insn_body(iseq, node_location->line, node_location->node_id, BIN(putnil), 0)->link);
4522 PUSH_INSN(ret, *node_location, swap);
4523
4524 if (lfinish[2]) PUSH_LABEL(ret, lfinish[2]);
4525 PUSH_INSN(ret, *node_location, pop);
4526 PUSH_LABEL(ret, lfinish[1]);
4527
4528 }
4529
4530 PUSH_LABEL(ret, lfinish[0]);
4531}
4532
4533// This is exactly the same as add_ensure_iseq, except it compiled
4534// the node as a Prism node, and not a CRuby node
4535static void
4536pm_add_ensure_iseq(LINK_ANCHOR *const ret, rb_iseq_t *iseq, int is_return, pm_scope_node_t *scope_node)
4537{
4538 RUBY_ASSERT(can_add_ensure_iseq(iseq));
4539
4540 struct iseq_compile_data_ensure_node_stack *enlp =
4541 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack;
4542 struct iseq_compile_data_ensure_node_stack *prev_enlp = enlp;
4543 DECL_ANCHOR(ensure);
4544
4545 while (enlp) {
4546 if (enlp->erange != NULL) {
4547 DECL_ANCHOR(ensure_part);
4548 LABEL *lstart = NEW_LABEL(0);
4549 LABEL *lend = NEW_LABEL(0);
4550
4551 add_ensure_range(iseq, enlp->erange, lstart, lend);
4552
4553 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enlp->prev;
4554 PUSH_LABEL(ensure_part, lstart);
4555 bool popped = true;
4556 PM_COMPILE_INTO_ANCHOR(ensure_part, (const pm_node_t *) enlp->ensure_node);
4557 PUSH_LABEL(ensure_part, lend);
4558 PUSH_SEQ(ensure, ensure_part);
4559 }
4560 else {
4561 if (!is_return) {
4562 break;
4563 }
4564 }
4565 enlp = enlp->prev;
4566 }
4567 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = prev_enlp;
4568 PUSH_SEQ(ret, ensure);
4569}
4570
4571 struct pm_local_table_insert_ctx {
4572 pm_scope_node_t *scope_node;
4573 rb_ast_id_table_t *local_table_for_iseq;
4574 int local_index;
4575};
4576
4577static int
4578pm_local_table_insert_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
4579{
4580 if (!existing) {
4581 pm_constant_id_t constant_id = (pm_constant_id_t) *key;
4582 struct pm_local_table_insert_ctx * ctx = (struct pm_local_table_insert_ctx *) arg;
4583
4584 pm_scope_node_t *scope_node = ctx->scope_node;
4585 rb_ast_id_table_t *local_table_for_iseq = ctx->local_table_for_iseq;
4586 int local_index = ctx->local_index;
4587
4588 ID local = pm_constant_id_lookup(scope_node, constant_id);
4589 local_table_for_iseq->ids[local_index] = local;
4590
4591 *value = (st_data_t)local_index;
4592
4593 ctx->local_index++;
4594 }
4595
4596 return ST_CONTINUE;
4597}
4598
4604static void
4605pm_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)
4606{
4607 RUBY_ASSERT((constant_id & PM_SPECIAL_CONSTANT_FLAG) == 0);
4608
4609 ID local = pm_constant_id_lookup(scope_node, constant_id);
4610 local_table_for_iseq->ids[local_index] = local;
4611 st_insert(index_lookup_table, (st_data_t) constant_id, (st_data_t) local_index);
4612}
4613
4618static void
4619pm_insert_local_special(ID local_name, int local_index, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq)
4620{
4621 local_table_for_iseq->ids[local_index] = local_name;
4622 st_insert(index_lookup_table, (st_data_t) (local_name | PM_SPECIAL_CONSTANT_FLAG), (st_data_t) local_index);
4623}
4624
4631static int
4632pm_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)
4633{
4634 for (size_t index = 0; index < node->lefts.size; index++) {
4635 const pm_node_t *left = node->lefts.nodes[index];
4636
4637 if (PM_NODE_TYPE_P(left, PM_REQUIRED_PARAMETER_NODE)) {
4638 if (!PM_NODE_FLAG_P(left, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4639 pm_insert_local_index(((const pm_required_parameter_node_t *) left)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4640 local_index++;
4641 }
4642 }
4643 else {
4644 RUBY_ASSERT(PM_NODE_TYPE_P(left, PM_MULTI_TARGET_NODE));
4645 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);
4646 }
4647 }
4648
4649 if (node->rest != NULL && PM_NODE_TYPE_P(node->rest, PM_SPLAT_NODE)) {
4650 const pm_splat_node_t *rest = (const pm_splat_node_t *) node->rest;
4651
4652 if (rest->expression != NULL) {
4653 RUBY_ASSERT(PM_NODE_TYPE_P(rest->expression, PM_REQUIRED_PARAMETER_NODE));
4654
4655 if (!PM_NODE_FLAG_P(rest->expression, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4656 pm_insert_local_index(((const pm_required_parameter_node_t *) rest->expression)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4657 local_index++;
4658 }
4659 }
4660 }
4661
4662 for (size_t index = 0; index < node->rights.size; index++) {
4663 const pm_node_t *right = node->rights.nodes[index];
4664
4665 if (PM_NODE_TYPE_P(right, PM_REQUIRED_PARAMETER_NODE)) {
4666 if (!PM_NODE_FLAG_P(right, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
4667 pm_insert_local_index(((const pm_required_parameter_node_t *) right)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4668 local_index++;
4669 }
4670 }
4671 else {
4672 RUBY_ASSERT(PM_NODE_TYPE_P(right, PM_MULTI_TARGET_NODE));
4673 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);
4674 }
4675 }
4676
4677 return local_index;
4678}
4679
4684static inline void
4685pm_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)
4686{
4687 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4688 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, node->name, 0);
4689 PUSH_SETLOCAL(ret, location, index.index, index.level);
4690}
4691
4700static void
4701pm_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)
4702{
4703 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4704 bool has_rest = (node->rest && PM_NODE_TYPE_P(node->rest, PM_SPLAT_NODE) && (((const pm_splat_node_t *) node->rest)->expression) != NULL);
4705 bool has_rights = node->rights.size > 0;
4706
4707 int flag = (has_rest || has_rights) ? 1 : 0;
4708 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->lefts.size), INT2FIX(flag));
4709
4710 for (size_t index = 0; index < node->lefts.size; index++) {
4711 const pm_node_t *left = node->lefts.nodes[index];
4712
4713 if (PM_NODE_TYPE_P(left, PM_REQUIRED_PARAMETER_NODE)) {
4714 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) left, ret, scope_node);
4715 }
4716 else {
4717 RUBY_ASSERT(PM_NODE_TYPE_P(left, PM_MULTI_TARGET_NODE));
4718 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) left, ret, scope_node);
4719 }
4720 }
4721
4722 if (has_rest) {
4723 if (has_rights) {
4724 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->rights.size), INT2FIX(3));
4725 }
4726
4727 const pm_node_t *rest = ((const pm_splat_node_t *) node->rest)->expression;
4728 RUBY_ASSERT(PM_NODE_TYPE_P(rest, PM_REQUIRED_PARAMETER_NODE));
4729
4730 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) rest, ret, scope_node);
4731 }
4732
4733 if (has_rights) {
4734 if (!has_rest) {
4735 PUSH_INSN2(ret, location, expandarray, INT2FIX(node->rights.size), INT2FIX(2));
4736 }
4737
4738 for (size_t index = 0; index < node->rights.size; index++) {
4739 const pm_node_t *right = node->rights.nodes[index];
4740
4741 if (PM_NODE_TYPE_P(right, PM_REQUIRED_PARAMETER_NODE)) {
4742 pm_compile_destructured_param_write(iseq, (const pm_required_parameter_node_t *) right, ret, scope_node);
4743 }
4744 else {
4745 RUBY_ASSERT(PM_NODE_TYPE_P(right, PM_MULTI_TARGET_NODE));
4746 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) right, ret, scope_node);
4747 }
4748 }
4749 }
4750}
4751
4756 typedef struct pm_multi_target_state_node {
4757 // The pointer to the topn instruction that will need to be modified after
4758 // we know the total stack size of all of the targets.
4759 INSN *topn;
4760
4761 // The index of the stack from the base of the entire multi target at which
4762 // the parent expression is located.
4763 size_t stack_index;
4764
4765 // The number of slots in the stack that this node occupies.
4766 size_t stack_size;
4767
4768 // The position of the node in the list of targets.
4769 size_t position;
4770
4771 // A pointer to the next node in this linked list.
4772 struct pm_multi_target_state_node *next;
4773} pm_multi_target_state_node_t;
4774
4782 typedef struct {
4783 // The total number of slots in the stack that this multi target occupies.
4784 size_t stack_size;
4785
4786 // The position of the current node being compiled. This is forwarded to
4787 // nodes when they are allocated.
4788 size_t position;
4789
4790 // A pointer to the head of this linked list.
4791 pm_multi_target_state_node_t *head;
4792
4793 // A pointer to the tail of this linked list.
4794 pm_multi_target_state_node_t *tail;
4795} pm_multi_target_state_t;
4796
4800static void
4801pm_multi_target_state_push(pm_multi_target_state_t *state, INSN *topn, size_t stack_size)
4802{
4803 pm_multi_target_state_node_t *node = ALLOC(pm_multi_target_state_node_t);
4804 node->topn = topn;
4805 node->stack_index = state->stack_size + 1;
4806 node->stack_size = stack_size;
4807 node->position = state->position;
4808 node->next = NULL;
4809
4810 if (state->head == NULL) {
4811 state->head = node;
4812 state->tail = node;
4813 }
4814 else {
4815 state->tail->next = node;
4816 state->tail = node;
4817 }
4818
4819 state->stack_size += stack_size;
4820}
4821
4827static void
4828pm_multi_target_state_update(pm_multi_target_state_t *state)
4829{
4830 // If nothing was ever pushed onto the stack, then we don't need to do any
4831 // kind of updates.
4832 if (state->stack_size == 0) return;
4833
4834 pm_multi_target_state_node_t *current = state->head;
4835 pm_multi_target_state_node_t *previous;
4836
4837 while (current != NULL) {
4838 VALUE offset = INT2FIX(state->stack_size - current->stack_index + current->position);
4839 current->topn->operands[0] = offset;
4840
4841 // stack_size will be > 1 in the case that we compiled an index target
4842 // and it had arguments. In this case, we use multiple topn instructions
4843 // to grab up all of the arguments as well, so those offsets need to be
4844 // updated as well.
4845 if (current->stack_size > 1) {
4846 INSN *insn = current->topn;
4847
4848 for (size_t index = 1; index < current->stack_size; index += 1) {
4849 LINK_ELEMENT *element = get_next_insn(insn);
4850 RUBY_ASSERT(IS_INSN(element));
4851
4852 insn = (INSN *) element;
4853 RUBY_ASSERT(insn->insn_id == BIN(topn));
4854
4855 insn->operands[0] = offset;
4856 }
4857 }
4858
4859 previous = current;
4860 current = current->next;
4861
4862 xfree(previous);
4863 }
4864}
4865
4866static void
4867pm_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);
4868
4897static void
4898pm_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)
4899{
4900 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4901
4902 switch (PM_NODE_TYPE(node)) {
4903 case PM_LOCAL_VARIABLE_TARGET_NODE: {
4904 // Local variable targets have no parent expression, so they only need
4905 // to compile the write.
4906 //
4907 // for i in []; end
4908 //
4909 const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
4910 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
4911
4912 PUSH_SETLOCAL(writes, location, index.index, index.level);
4913 break;
4914 }
4915 case PM_CLASS_VARIABLE_TARGET_NODE: {
4916 // Class variable targets have no parent expression, so they only need
4917 // to compile the write.
4918 //
4919 // for @@i in []; end
4920 //
4921 const pm_class_variable_target_node_t *cast = (const pm_class_variable_target_node_t *) node;
4922 ID name = pm_constant_id_lookup(scope_node, cast->name);
4923
4924 VALUE operand = ID2SYM(name);
4925 PUSH_INSN2(writes, location, setclassvariable, operand, get_cvar_ic_value(iseq, name));
4926 break;
4927 }
4928 case PM_CONSTANT_TARGET_NODE: {
4929 // Constant targets have no parent expression, so they only need to
4930 // compile the write.
4931 //
4932 // for I in []; end
4933 //
4934 const pm_constant_target_node_t *cast = (const pm_constant_target_node_t *) node;
4935 ID name = pm_constant_id_lookup(scope_node, cast->name);
4936
4937 VALUE operand = ID2SYM(name);
4938 PUSH_INSN1(writes, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
4939 PUSH_INSN1(writes, location, setconstant, operand);
4940 break;
4941 }
4942 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
4943 // Global variable targets have no parent expression, so they only need
4944 // to compile the write.
4945 //
4946 // for $i in []; end
4947 //
4948 const pm_global_variable_target_node_t *cast = (const pm_global_variable_target_node_t *) node;
4949 ID name = pm_constant_id_lookup(scope_node, cast->name);
4950
4951 VALUE operand = ID2SYM(name);
4952 PUSH_INSN1(writes, location, setglobal, operand);
4953 break;
4954 }
4955 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
4956 // Instance variable targets have no parent expression, so they only
4957 // need to compile the write.
4958 //
4959 // for @i in []; end
4960 //
4961 const pm_instance_variable_target_node_t *cast = (const pm_instance_variable_target_node_t *) node;
4962 ID name = pm_constant_id_lookup(scope_node, cast->name);
4963
4964 VALUE operand = ID2SYM(name);
4965 PUSH_INSN2(writes, location, setinstancevariable, operand, get_ivar_ic_value(iseq, name));
4966 break;
4967 }
4968 case PM_CONSTANT_PATH_TARGET_NODE: {
4969 // Constant path targets have a parent expression that is the object
4970 // that owns the constant. This needs to be compiled first into the
4971 // parents sequence. If no parent is found, then it represents using the
4972 // unary :: operator to indicate a top-level constant. In that case we
4973 // need to push Object onto the stack.
4974 //
4975 // for I::J in []; end
4976 //
4977 const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
4978 ID name = pm_constant_id_lookup(scope_node, cast->name);
4979
4980 if (cast->parent != NULL) {
4981 pm_compile_node(iseq, cast->parent, parents, false, scope_node);
4982 }
4983 else {
4984 PUSH_INSN1(parents, location, putobject, rb_cObject);
4985 }
4986
4987 if (state == NULL) {
4988 PUSH_INSN(writes, location, swap);
4989 }
4990 else {
4991 PUSH_INSN1(writes, location, topn, INT2FIX(1));
4992 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
4993 }
4994
4995 VALUE operand = ID2SYM(name);
4996 PUSH_INSN1(writes, location, setconstant, operand);
4997
4998 if (state != NULL) {
4999 PUSH_INSN(cleanup, location, pop);
5000 }
5001
5002 break;
5003 }
5004 case PM_CALL_TARGET_NODE: {
5005 // Call targets have a parent expression that is the receiver of the
5006 // method being called. This needs to be compiled first into the parents
5007 // sequence. These nodes cannot have arguments, so the method call is
5008 // compiled with a single argument which represents the value being
5009 // written.
5010 //
5011 // for i.j in []; end
5012 //
5013 const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
5014 ID method_id = pm_constant_id_lookup(scope_node, cast->name);
5015
5016 pm_compile_node(iseq, cast->receiver, parents, false, scope_node);
5017
5018 LABEL *safe_label = NULL;
5019 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5020 safe_label = NEW_LABEL(location.line);
5021 PUSH_INSN(parents, location, dup);
5022 PUSH_INSNL(parents, location, branchnil, safe_label);
5023 }
5024
5025 if (state != NULL) {
5026 PUSH_INSN1(writes, location, topn, INT2FIX(1));
5027 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
5028 PUSH_INSN(writes, location, swap);
5029 }
5030
5031 int flags = VM_CALL_ARGS_SIMPLE;
5032 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) flags |= VM_CALL_FCALL;
5033
5034 PUSH_SEND_WITH_FLAG(writes, location, method_id, INT2FIX(1), INT2FIX(flags));
5035 if (safe_label != NULL && state == NULL) PUSH_LABEL(writes, safe_label);
5036 PUSH_INSN(writes, location, pop);
5037 if (safe_label != NULL && state != NULL) PUSH_LABEL(writes, safe_label);
5038
5039 if (state != NULL) {
5040 PUSH_INSN(cleanup, location, pop);
5041 }
5042
5043 break;
5044 }
5045 case PM_INDEX_TARGET_NODE: {
5046 // Index targets have a parent expression that is the receiver of the
5047 // method being called and any additional arguments that are being
5048 // passed along with the value being written. The receiver and arguments
5049 // both need to be on the stack. Note that this is even more complicated
5050 // by the fact that these nodes can hold a block using the unary &
5051 // operator.
5052 //
5053 // for i[:j] in []; end
5054 //
5055 const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
5056
5057 pm_compile_node(iseq, cast->receiver, parents, false, scope_node);
5058
5059 int flags = 0;
5060 struct rb_callinfo_kwarg *kwargs = NULL;
5061 int argc = pm_setup_args(cast->arguments, (const pm_node_t *) cast->block, &flags, &kwargs, iseq, parents, scope_node, &location);
5062
5063 if (state != NULL) {
5064 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5065 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), argc + 1);
5066
5067 if (argc == 0) {
5068 PUSH_INSN(writes, location, swap);
5069 }
5070 else {
5071 for (int index = 0; index < argc; index++) {
5072 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5073 }
5074 PUSH_INSN1(writes, location, topn, INT2FIX(argc + 1));
5075 }
5076 }
5077
5078 // The argc that we're going to pass to the send instruction is the
5079 // number of arguments + 1 for the value being written. If there's a
5080 // splat, then we need to insert newarray and concatarray instructions
5081 // after the arguments have been written.
5082 int ci_argc = argc + 1;
5083 if (flags & VM_CALL_ARGS_SPLAT) {
5084 ci_argc--;
5085 PUSH_INSN1(writes, location, newarray, INT2FIX(1));
5086 PUSH_INSN(writes, location, concatarray);
5087 }
5088
5089 PUSH_SEND_R(writes, location, idASET, INT2NUM(ci_argc), NULL, INT2FIX(flags), kwargs);
5090 PUSH_INSN(writes, location, pop);
5091
5092 if (state != NULL) {
5093 if (argc != 0) {
5094 PUSH_INSN(writes, location, pop);
5095 }
5096
5097 for (int index = 0; index < argc + 1; index++) {
5098 PUSH_INSN(cleanup, location, pop);
5099 }
5100 }
5101
5102 break;
5103 }
5104 case PM_MULTI_TARGET_NODE: {
5105 // Multi target nodes represent a set of writes to multiple variables.
5106 // The parent expressions are the combined set of the parent expressions
5107 // of its inner target nodes.
5108 //
5109 // for i, j in []; end
5110 //
5111 size_t before_position;
5112 if (state != NULL) {
5113 before_position = state->position;
5114 state->position--;
5115 }
5116
5117 pm_compile_multi_target_node(iseq, node, parents, writes, cleanup, scope_node, state);
5118 if (state != NULL) state->position = before_position;
5119
5120 break;
5121 }
5122 default:
5123 rb_bug("Unexpected node type: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5124 break;
5125 }
5126}
5127
5133static void
5134pm_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)
5135{
5136 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5137 const pm_node_list_t *lefts;
5138 const pm_node_t *rest;
5139 const pm_node_list_t *rights;
5140
5141 switch (PM_NODE_TYPE(node)) {
5142 case PM_MULTI_TARGET_NODE: {
5143 const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
5144 lefts = &cast->lefts;
5145 rest = cast->rest;
5146 rights = &cast->rights;
5147 break;
5148 }
5149 case PM_MULTI_WRITE_NODE: {
5150 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
5151 lefts = &cast->lefts;
5152 rest = cast->rest;
5153 rights = &cast->rights;
5154 break;
5155 }
5156 default:
5157 rb_bug("Unsupported node %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5158 break;
5159 }
5160
5161 bool has_rest = (rest != NULL) && PM_NODE_TYPE_P(rest, PM_SPLAT_NODE) && ((const pm_splat_node_t *) rest)->expression != NULL;
5162 bool has_posts = rights->size > 0;
5163
5164 // The first instruction in the writes sequence is going to spread the
5165 // top value of the stack onto the number of values that we're going to
5166 // write.
5167 PUSH_INSN2(writes, location, expandarray, INT2FIX(lefts->size), INT2FIX((has_rest || has_posts) ? 1 : 0));
5168
5169 // We need to keep track of some additional state information as we're
5170 // going through the targets because we will need to revisit them once
5171 // we know how many values are being pushed onto the stack.
5172 pm_multi_target_state_t target_state = { 0 };
5173 if (state == NULL) state = &target_state;
5174
5175 size_t base_position = state->position;
5176 size_t splat_position = (has_rest || has_posts) ? 1 : 0;
5177
5178 // Next, we'll iterate through all of the leading targets.
5179 for (size_t index = 0; index < lefts->size; index++) {
5180 const pm_node_t *target = lefts->nodes[index];
5181 state->position = lefts->size - index + splat_position + base_position;
5182 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5183 }
5184
5185 // Next, we'll compile the rest target if there is one.
5186 if (has_rest) {
5187 const pm_node_t *target = ((const pm_splat_node_t *) rest)->expression;
5188 state->position = 1 + rights->size + base_position;
5189
5190 if (has_posts) {
5191 PUSH_INSN2(writes, location, expandarray, INT2FIX(rights->size), INT2FIX(3));
5192 }
5193
5194 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5195 }
5196
5197 // Finally, we'll compile the trailing targets.
5198 if (has_posts) {
5199 if (!has_rest && rest != NULL) {
5200 PUSH_INSN2(writes, location, expandarray, INT2FIX(rights->size), INT2FIX(2));
5201 }
5202
5203 for (size_t index = 0; index < rights->size; index++) {
5204 const pm_node_t *target = rights->nodes[index];
5205 state->position = rights->size - index + base_position;
5206 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5207 }
5208 }
5209}
5210
5216static void
5217pm_compile_for_node_index(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, pm_scope_node_t *scope_node)
5218{
5219 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5220
5221 switch (PM_NODE_TYPE(node)) {
5222 case PM_LOCAL_VARIABLE_TARGET_NODE: {
5223 // For local variables, all we have to do is retrieve the value and then
5224 // compile the index node.
5225 PUSH_GETLOCAL(ret, location, 1, 0);
5226 pm_compile_target_node(iseq, node, ret, ret, ret, scope_node, NULL);
5227 break;
5228 }
5229 case PM_CLASS_VARIABLE_TARGET_NODE:
5230 case PM_CONSTANT_TARGET_NODE:
5231 case PM_GLOBAL_VARIABLE_TARGET_NODE:
5232 case PM_INSTANCE_VARIABLE_TARGET_NODE:
5233 case PM_CONSTANT_PATH_TARGET_NODE:
5234 case PM_CALL_TARGET_NODE:
5235 case PM_INDEX_TARGET_NODE: {
5236 // For other targets, we need to potentially compile the parent or
5237 // owning expression of this target, then retrieve the value, expand it,
5238 // and then compile the necessary writes.
5239 DECL_ANCHOR(writes);
5240 DECL_ANCHOR(cleanup);
5241
5242 pm_multi_target_state_t state = { 0 };
5243 state.position = 1;
5244 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
5245
5246 PUSH_GETLOCAL(ret, location, 1, 0);
5247 PUSH_INSN2(ret, location, expandarray, INT2FIX(1), INT2FIX(0));
5248
5249 PUSH_SEQ(ret, writes);
5250 PUSH_SEQ(ret, cleanup);
5251
5252 pm_multi_target_state_update(&state);
5253 break;
5254 }
5255 case PM_MULTI_TARGET_NODE: {
5256 DECL_ANCHOR(writes);
5257 DECL_ANCHOR(cleanup);
5258
5259 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, NULL);
5260
5261 LABEL *not_single = NEW_LABEL(location.line);
5262 LABEL *not_ary = NEW_LABEL(location.line);
5263
5264 // When there are multiple targets, we'll do a bunch of work to convert
5265 // the value into an array before we expand it. Effectively we're trying
5266 // to accomplish:
5267 //
5268 // (args.length == 1 && Array.try_convert(args[0])) || args
5269 //
5270 PUSH_GETLOCAL(ret, location, 1, 0);
5271 PUSH_INSN(ret, location, dup);
5272 PUSH_CALL(ret, location, idLength, INT2FIX(0));
5273 PUSH_INSN1(ret, location, putobject, INT2FIX(1));
5274 PUSH_CALL(ret, location, idEq, INT2FIX(1));
5275 PUSH_INSNL(ret, location, branchunless, not_single);
5276 PUSH_INSN(ret, location, dup);
5277 PUSH_INSN1(ret, location, putobject, INT2FIX(0));
5278 PUSH_CALL(ret, location, idAREF, INT2FIX(1));
5279 PUSH_INSN1(ret, location, putobject, rb_cArray);
5280 PUSH_INSN(ret, location, swap);
5281 PUSH_CALL(ret, location, rb_intern("try_convert"), INT2FIX(1));
5282 PUSH_INSN(ret, location, dup);
5283 PUSH_INSNL(ret, location, branchunless, not_ary);
5284 PUSH_INSN(ret, location, swap);
5285
5286 PUSH_LABEL(ret, not_ary);
5287 PUSH_INSN(ret, location, pop);
5288
5289 PUSH_LABEL(ret, not_single);
5290 PUSH_SEQ(ret, writes);
5291 PUSH_SEQ(ret, cleanup);
5292 break;
5293 }
5294 default:
5295 rb_bug("Unexpected node type for index in for node: %s", pm_node_type_to_str(PM_NODE_TYPE(node)));
5296 break;
5297 }
5298}
5299
5300static void
5301pm_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)
5302{
5303 const pm_parser_t *parser = scope_node->parser;
5304
5305 LABEL *lstart = NEW_LABEL(node_location->line);
5306 LABEL *lend = NEW_LABEL(node_location->line);
5307 LABEL *lcont = NEW_LABEL(node_location->line);
5308
5309 pm_scope_node_t rescue_scope_node;
5310 pm_scope_node_init((const pm_node_t *) cast->rescue_clause, &rescue_scope_node, scope_node);
5311
5312 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
5313 &rescue_scope_node,
5314 rb_str_concat(rb_str_new2("rescue in "), ISEQ_BODY(iseq)->location.label),
5315 ISEQ_TYPE_RESCUE,
5316 pm_node_line_number(parser, (const pm_node_t *) cast->rescue_clause)
5317 );
5318
5319 pm_scope_node_destroy(&rescue_scope_node);
5320
5321 lstart->rescued = LABEL_RESCUE_BEG;
5322 lend->rescued = LABEL_RESCUE_END;
5323 PUSH_LABEL(ret, lstart);
5324
5325 bool prev_in_rescue = ISEQ_COMPILE_DATA(iseq)->in_rescue;
5326 ISEQ_COMPILE_DATA(iseq)->in_rescue = true;
5327
5328 if (cast->statements != NULL) {
5329 PM_COMPILE_NOT_POPPED((const pm_node_t *) cast->statements);
5330 }
5331 else {
5332 const pm_node_location_t location = PM_NODE_START_LOCATION(parser, cast->rescue_clause);
5333 PUSH_INSN(ret, location, putnil);
5334 }
5335
5336 ISEQ_COMPILE_DATA(iseq)->in_rescue = prev_in_rescue;
5337 PUSH_LABEL(ret, lend);
5338
5339 if (cast->else_clause != NULL) {
5340 if (!popped) PUSH_INSN(ret, *node_location, pop);
5341 PM_COMPILE((const pm_node_t *) cast->else_clause);
5342 }
5343
5344 PUSH_INSN(ret, *node_location, nop);
5345 PUSH_LABEL(ret, lcont);
5346
5347 if (popped) PUSH_INSN(ret, *node_location, pop);
5348 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
5349 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
5350}
5351
5352static void
5353pm_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)
5354{
5355 const pm_parser_t *parser = scope_node->parser;
5356 const pm_statements_node_t *statements = cast->ensure_clause->statements;
5357
5358 pm_node_location_t location;
5359 if (statements != NULL) {
5360 location = PM_NODE_START_LOCATION(parser, statements);
5361 }
5362 else {
5363 location = *node_location;
5364 }
5365
5366 LABEL *lstart = NEW_LABEL(location.line);
5367 LABEL *lend = NEW_LABEL(location.line);
5368 LABEL *lcont = NEW_LABEL(location.line);
5369
5370 struct ensure_range er;
5371 struct iseq_compile_data_ensure_node_stack enl;
5372 struct ensure_range *erange;
5373
5374 DECL_ANCHOR(ensr);
5375 if (statements != NULL) {
5376 pm_compile_node(iseq, (const pm_node_t *) statements, ensr, true, scope_node);
5377 }
5378
5379 LINK_ELEMENT *last = ensr->last;
5380 bool last_leave = last && IS_INSN(last) && IS_INSN_ID(last, leave);
5381
5382 er.begin = lstart;
5383 er.end = lend;
5384 er.next = 0;
5385 push_ensure_entry(iseq, &enl, &er, (void *) cast->ensure_clause);
5386
5387 PUSH_LABEL(ret, lstart);
5388 if (cast->rescue_clause != NULL) {
5389 pm_compile_rescue(iseq, cast, node_location, ret, popped | last_leave, scope_node);
5390 }
5391 else if (cast->statements != NULL) {
5392 pm_compile_node(iseq, (const pm_node_t *) cast->statements, ret, popped | last_leave, scope_node);
5393 }
5394 else if (!(popped | last_leave)) {
5395 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
5396 }
5397
5398 PUSH_LABEL(ret, lend);
5399 PUSH_SEQ(ret, ensr);
5400 if (!popped && last_leave) PUSH_INSN(ret, *node_location, putnil);
5401 PUSH_LABEL(ret, lcont);
5402 if (last_leave) PUSH_INSN(ret, *node_location, pop);
5403
5404 pm_scope_node_t next_scope_node;
5405 pm_scope_node_init((const pm_node_t *) cast->ensure_clause, &next_scope_node, scope_node);
5406
5407 rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(
5408 &next_scope_node,
5409 rb_str_concat(rb_str_new2("ensure in "), ISEQ_BODY(iseq)->location.label),
5410 ISEQ_TYPE_ENSURE,
5411 location.line
5412 );
5413
5414 pm_scope_node_destroy(&next_scope_node);
5415
5416 erange = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->erange;
5417 if (lstart->link.next != &lend->link) {
5418 while (erange) {
5419 PUSH_CATCH_ENTRY(CATCH_TYPE_ENSURE, erange->begin, erange->end, child_iseq, lcont);
5420 erange = erange->next;
5421 }
5422 }
5423 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enl.prev;
5424}
5425
5430static inline bool
5431pm_opt_str_freeze_p(const rb_iseq_t *iseq, const pm_call_node_t *node)
5432{
5433 return (
5434 !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) &&
5435 node->receiver != NULL &&
5436 PM_NODE_TYPE_P(node->receiver, PM_STRING_NODE) &&
5437 node->arguments == NULL &&
5438 node->block == NULL &&
5439 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5440 );
5441}
5442
5447static inline bool
5448pm_opt_aref_with_p(const rb_iseq_t *iseq, const pm_call_node_t *node)
5449{
5450 return (
5451 !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) &&
5452 node->arguments != NULL &&
5453 PM_NODE_TYPE_P((const pm_node_t *) node->arguments, PM_ARGUMENTS_NODE) &&
5454 ((const pm_arguments_node_t *) node->arguments)->arguments.size == 1 &&
5455 PM_NODE_TYPE_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_NODE) &&
5456 node->block == NULL &&
5457 !PM_NODE_FLAG_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_FLAGS_FROZEN) &&
5458 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5459 );
5460}
5461
5466static inline bool
5467pm_opt_aset_with_p(const rb_iseq_t *iseq, const pm_call_node_t *node)
5468{
5469 return (
5470 !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) &&
5471 node->arguments != NULL &&
5472 PM_NODE_TYPE_P((const pm_node_t *) node->arguments, PM_ARGUMENTS_NODE) &&
5473 ((const pm_arguments_node_t *) node->arguments)->arguments.size == 2 &&
5474 PM_NODE_TYPE_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_NODE) &&
5475 node->block == NULL &&
5476 !PM_NODE_FLAG_P(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0], PM_STRING_FLAGS_FROZEN) &&
5477 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5478 );
5479}
5480
5485static void
5486pm_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)
5487{
5488 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, name_loc, node_id);
5489
5490 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache) {
5491 ISEQ_BODY(iseq)->ic_size++;
5492 VALUE segments = rb_ary_new_from_args(1, name);
5493 PUSH_INSN1(ret, location, opt_getconstant_path, segments);
5494 }
5495 else {
5496 PUSH_INSN(ret, location, putnil);
5497 PUSH_INSN1(ret, location, putobject, Qtrue);
5498 PUSH_INSN1(ret, location, getconstant, name);
5499 }
5500}
5501
5506static VALUE
5507pm_constant_path_parts(const pm_node_t *node, const pm_scope_node_t *scope_node)
5508{
5509 VALUE parts = rb_ary_new();
5510
5511 while (true) {
5512 switch (PM_NODE_TYPE(node)) {
5513 case PM_CONSTANT_READ_NODE: {
5514 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
5515 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5516
5517 rb_ary_unshift(parts, name);
5518 return parts;
5519 }
5520 case PM_CONSTANT_PATH_NODE: {
5521 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
5522 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5523
5524 rb_ary_unshift(parts, name);
5525 if (cast->parent == NULL) {
5526 rb_ary_unshift(parts, ID2SYM(idNULL));
5527 return parts;
5528 }
5529
5530 node = cast->parent;
5531 break;
5532 }
5533 default:
5534 return Qnil;
5535 }
5536 }
5537}
5538
5544static void
5545pm_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)
5546{
5547 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5548
5549 switch (PM_NODE_TYPE(node)) {
5550 case PM_CONSTANT_READ_NODE: {
5551 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
5552 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5553
5554 PUSH_INSN1(body, location, putobject, Qtrue);
5555 PUSH_INSN1(body, location, getconstant, name);
5556 break;
5557 }
5558 case PM_CONSTANT_PATH_NODE: {
5559 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
5560 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
5561
5562 if (cast->parent == NULL) {
5563 PUSH_INSN(body, location, pop);
5564 PUSH_INSN1(body, location, putobject, rb_cObject);
5565 PUSH_INSN1(body, location, putobject, Qtrue);
5566 PUSH_INSN1(body, location, getconstant, name);
5567 }
5568 else {
5569 pm_compile_constant_path(iseq, cast->parent, prefix, body, false, scope_node);
5570 PUSH_INSN1(body, location, putobject, Qfalse);
5571 PUSH_INSN1(body, location, getconstant, name);
5572 }
5573 break;
5574 }
5575 default:
5576 PM_COMPILE_INTO_ANCHOR(prefix, node);
5577 break;
5578 }
5579}
5580
5584static VALUE
5585pm_compile_shareable_constant_literal(rb_iseq_t *iseq, const pm_node_t *node, const pm_scope_node_t *scope_node)
5586{
5587 switch (PM_NODE_TYPE(node)) {
5588 case PM_TRUE_NODE:
5589 case PM_FALSE_NODE:
5590 case PM_NIL_NODE:
5591 case PM_SYMBOL_NODE:
5592 case PM_REGULAR_EXPRESSION_NODE:
5593 case PM_SOURCE_LINE_NODE:
5594 case PM_INTEGER_NODE:
5595 case PM_FLOAT_NODE:
5596 case PM_RATIONAL_NODE:
5597 case PM_IMAGINARY_NODE:
5598 case PM_SOURCE_ENCODING_NODE:
5599 return pm_static_literal_value(iseq, node, scope_node);
5600 case PM_STRING_NODE:
5601 return parse_static_literal_string(iseq, scope_node, node, &((const pm_string_node_t *) node)->unescaped);
5602 case PM_SOURCE_FILE_NODE:
5603 return pm_source_file_value((const pm_source_file_node_t *) node, scope_node);
5604 case PM_ARRAY_NODE: {
5605 const pm_array_node_t *cast = (const pm_array_node_t *) node;
5606 VALUE result = rb_ary_new_capa(cast->elements.size);
5607
5608 for (size_t index = 0; index < cast->elements.size; index++) {
5609 VALUE element = pm_compile_shareable_constant_literal(iseq, cast->elements.nodes[index], scope_node);
5610 if (element == Qundef) return Qundef;
5611
5612 rb_ary_push(result, element);
5613 }
5614
5615 return rb_ractor_make_shareable(result);
5616 }
5617 case PM_HASH_NODE: {
5618 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
5619 VALUE result = rb_hash_new_capa(cast->elements.size);
5620
5621 for (size_t index = 0; index < cast->elements.size; index++) {
5622 const pm_node_t *element = cast->elements.nodes[index];
5623 if (!PM_NODE_TYPE_P(element, PM_ASSOC_NODE)) return Qundef;
5624
5625 const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
5626
5627 VALUE key = pm_compile_shareable_constant_literal(iseq, assoc->key, scope_node);
5628 if (key == Qundef) return Qundef;
5629
5630 VALUE value = pm_compile_shareable_constant_literal(iseq, assoc->value, scope_node);
5631 if (value == Qundef) return Qundef;
5632
5633 rb_hash_aset(result, key, value);
5634 }
5635
5636 return rb_ractor_make_shareable(result);
5637 }
5638 default:
5639 return Qundef;
5640 }
5641}
5642
5647static void
5648pm_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)
5649{
5650 VALUE literal = pm_compile_shareable_constant_literal(iseq, node, scope_node);
5651 if (literal != Qundef) {
5652 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5653 PUSH_INSN1(ret, location, putobject, literal);
5654 return;
5655 }
5656
5657 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5658 switch (PM_NODE_TYPE(node)) {
5659 case PM_ARRAY_NODE: {
5660 const pm_array_node_t *cast = (const pm_array_node_t *) node;
5661
5662 if (top) {
5663 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5664 }
5665
5666 for (size_t index = 0; index < cast->elements.size; index++) {
5667 pm_compile_shareable_constant_value(iseq, cast->elements.nodes[index], shareability, path, ret, scope_node, false);
5668 }
5669
5670 PUSH_INSN1(ret, location, newarray, INT2FIX(cast->elements.size));
5671
5672 if (top) {
5673 ID method_id = (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) ? rb_intern("make_shareable_copy") : rb_intern("make_shareable");
5674 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5675 }
5676
5677 return;
5678 }
5679 case PM_HASH_NODE: {
5680 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
5681
5682 if (top) {
5683 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5684 }
5685
5686 pm_compile_hash_elements(iseq, (const pm_node_t *) cast, &cast->elements, shareability, path, false, ret, scope_node);
5687
5688 if (top) {
5689 ID method_id = (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) ? rb_intern("make_shareable_copy") : rb_intern("make_shareable");
5690 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5691 }
5692
5693 return;
5694 }
5695 default: {
5696 DECL_ANCHOR(value_seq);
5697
5698 pm_compile_node(iseq, node, value_seq, false, scope_node);
5699 if (PM_NODE_TYPE_P(node, PM_INTERPOLATED_STRING_NODE)) {
5700 PUSH_SEND_WITH_FLAG(value_seq, location, idUMinus, INT2FIX(0), INT2FIX(VM_CALL_ARGS_SIMPLE));
5701 }
5702
5703 if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL) {
5704 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5705 PUSH_SEQ(ret, value_seq);
5706 PUSH_INSN1(ret, location, putobject, path);
5707 PUSH_SEND_WITH_FLAG(ret, location, rb_intern("ensure_shareable"), INT2FIX(2), INT2FIX(VM_CALL_ARGS_SIMPLE));
5708 }
5709 else if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) {
5710 if (top) PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5711 PUSH_SEQ(ret, value_seq);
5712 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern("make_shareable_copy"), INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5713 }
5714 else if (shareability & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING) {
5715 if (top) PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5716 PUSH_SEQ(ret, value_seq);
5717 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern("make_shareable"), INT2FIX(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5718 }
5719
5720 break;
5721 }
5722 }
5723}
5724
5729static void
5730pm_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)
5731{
5732 const pm_node_location_t location = *node_location;
5733 ID name_id = pm_constant_id_lookup(scope_node, node->name);
5734
5735 if (shareability != 0) {
5736 pm_compile_shareable_constant_value(iseq, node->value, shareability, rb_id2str(name_id), ret, scope_node, true);
5737 }
5738 else {
5739 PM_COMPILE_NOT_POPPED(node->value);
5740 }
5741
5742 if (!popped) PUSH_INSN(ret, location, dup);
5743 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5744
5745 VALUE operand = ID2SYM(name_id);
5746 PUSH_INSN1(ret, location, setconstant, operand);
5747}
5748
5753static void
5754pm_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)
5755{
5756 const pm_node_location_t location = *node_location;
5757
5758 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5759 LABEL *end_label = NEW_LABEL(location.line);
5760
5761 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5762 if (!popped) PUSH_INSN(ret, location, dup);
5763
5764 PUSH_INSNL(ret, location, branchunless, end_label);
5765 if (!popped) PUSH_INSN(ret, location, pop);
5766
5767 if (shareability != 0) {
5768 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5769 }
5770 else {
5771 PM_COMPILE_NOT_POPPED(node->value);
5772 }
5773
5774 if (!popped) PUSH_INSN(ret, location, dup);
5775 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5776 PUSH_INSN1(ret, location, setconstant, name);
5777 PUSH_LABEL(ret, end_label);
5778}
5779
5784static void
5785pm_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)
5786{
5787 const pm_node_location_t location = *node_location;
5788 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5789
5790 LABEL *set_label = NEW_LABEL(location.line);
5791 LABEL *end_label = NEW_LABEL(location.line);
5792
5793 PUSH_INSN(ret, location, putnil);
5794 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST), name, Qtrue);
5795 PUSH_INSNL(ret, location, branchunless, set_label);
5796
5797 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5798 if (!popped) PUSH_INSN(ret, location, dup);
5799
5800 PUSH_INSNL(ret, location, branchif, end_label);
5801 if (!popped) PUSH_INSN(ret, location, pop);
5802 PUSH_LABEL(ret, set_label);
5803
5804 if (shareability != 0) {
5805 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5806 }
5807 else {
5808 PM_COMPILE_NOT_POPPED(node->value);
5809 }
5810
5811 if (!popped) PUSH_INSN(ret, location, dup);
5812 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5813 PUSH_INSN1(ret, location, setconstant, name);
5814 PUSH_LABEL(ret, end_label);
5815}
5816
5821static void
5822pm_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)
5823{
5824 const pm_node_location_t location = *node_location;
5825
5826 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, node->name));
5827 ID method_id = pm_constant_id_lookup(scope_node, node->binary_operator);
5828
5829 pm_compile_constant_read(iseq, name, &node->name_loc, location.node_id, ret, scope_node);
5830
5831 if (shareability != 0) {
5832 pm_compile_shareable_constant_value(iseq, node->value, shareability, name, ret, scope_node, true);
5833 }
5834 else {
5835 PM_COMPILE_NOT_POPPED(node->value);
5836 }
5837
5838 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
5839 if (!popped) PUSH_INSN(ret, location, dup);
5840
5841 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5842 PUSH_INSN1(ret, location, setconstant, name);
5843}
5844
5849static VALUE
5850pm_constant_path_path(const pm_constant_path_node_t *node, const pm_scope_node_t *scope_node)
5851{
5852 VALUE parts = rb_ary_new();
5853 rb_ary_push(parts, rb_id2str(pm_constant_id_lookup(scope_node, node->name)));
5854
5855 const pm_node_t *current = node->parent;
5856 while (current != NULL && PM_NODE_TYPE_P(current, PM_CONSTANT_PATH_NODE)) {
5857 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) current;
5858 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, cast->name)));
5859 current = cast->parent;
5860 }
5861
5862 if (current == NULL) {
5863 rb_ary_unshift(parts, rb_id2str(idNULL));
5864 }
5865 else if (PM_NODE_TYPE_P(current, PM_CONSTANT_READ_NODE)) {
5866 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, ((const pm_constant_read_node_t *) current)->name)));
5867 }
5868 else {
5869 rb_ary_unshift(parts, rb_str_new_cstr("..."));
5870 }
5871
5872 return rb_ary_join(parts, rb_str_new_cstr("::"));
5873}
5874
5879static void
5880pm_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)
5881{
5882 const pm_node_location_t location = *node_location;
5883 const pm_constant_path_node_t *target = node->target;
5884 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5885
5886 if (target->parent) {
5887 PM_COMPILE_NOT_POPPED((const pm_node_t *) target->parent);
5888 }
5889 else {
5890 PUSH_INSN1(ret, location, putobject, rb_cObject);
5891 }
5892
5893 if (shareability != 0) {
5894 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
5895 }
5896 else {
5897 PM_COMPILE_NOT_POPPED(node->value);
5898 }
5899
5900 if (!popped) {
5901 PUSH_INSN(ret, location, swap);
5902 PUSH_INSN1(ret, location, topn, INT2FIX(1));
5903 }
5904
5905 PUSH_INSN(ret, location, swap);
5906 PUSH_INSN1(ret, location, setconstant, name);
5907}
5908
5913static void
5914pm_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)
5915{
5916 const pm_node_location_t location = *node_location;
5917 const pm_constant_path_node_t *target = node->target;
5918
5919 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5920 LABEL *lfin = NEW_LABEL(location.line);
5921
5922 if (target->parent) {
5923 PM_COMPILE_NOT_POPPED(target->parent);
5924 }
5925 else {
5926 PUSH_INSN1(ret, location, putobject, rb_cObject);
5927 }
5928
5929 PUSH_INSN(ret, location, dup);
5930 PUSH_INSN1(ret, location, putobject, Qtrue);
5931 PUSH_INSN1(ret, location, getconstant, name);
5932
5933 if (!popped) PUSH_INSN(ret, location, dup);
5934 PUSH_INSNL(ret, location, branchunless, lfin);
5935
5936 if (!popped) PUSH_INSN(ret, location, pop);
5937
5938 if (shareability != 0) {
5939 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
5940 }
5941 else {
5942 PM_COMPILE_NOT_POPPED(node->value);
5943 }
5944
5945 if (popped) {
5946 PUSH_INSN1(ret, location, topn, INT2FIX(1));
5947 }
5948 else {
5949 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
5950 PUSH_INSN(ret, location, swap);
5951 }
5952
5953 PUSH_INSN1(ret, location, setconstant, name);
5954 PUSH_LABEL(ret, lfin);
5955
5956 if (!popped) PUSH_INSN(ret, location, swap);
5957 PUSH_INSN(ret, location, pop);
5958}
5959
5964static void
5965pm_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)
5966{
5967 const pm_node_location_t location = *node_location;
5968 const pm_constant_path_node_t *target = node->target;
5969
5970 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
5971 LABEL *lassign = NEW_LABEL(location.line);
5972 LABEL *lfin = NEW_LABEL(location.line);
5973
5974 if (target->parent) {
5975 PM_COMPILE_NOT_POPPED(target->parent);
5976 }
5977 else {
5978 PUSH_INSN1(ret, location, putobject, rb_cObject);
5979 }
5980
5981 PUSH_INSN(ret, location, dup);
5982 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CONST_FROM), name, Qtrue);
5983 PUSH_INSNL(ret, location, branchunless, lassign);
5984
5985 PUSH_INSN(ret, location, dup);
5986 PUSH_INSN1(ret, location, putobject, Qtrue);
5987 PUSH_INSN1(ret, location, getconstant, name);
5988
5989 if (!popped) PUSH_INSN(ret, location, dup);
5990 PUSH_INSNL(ret, location, branchif, lfin);
5991
5992 if (!popped) PUSH_INSN(ret, location, pop);
5993 PUSH_LABEL(ret, lassign);
5994
5995 if (shareability != 0) {
5996 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
5997 }
5998 else {
5999 PM_COMPILE_NOT_POPPED(node->value);
6000 }
6001
6002 if (popped) {
6003 PUSH_INSN1(ret, location, topn, INT2FIX(1));
6004 }
6005 else {
6006 PUSH_INSN1(ret, location, dupn, INT2FIX(2));
6007 PUSH_INSN(ret, location, swap);
6008 }
6009
6010 PUSH_INSN1(ret, location, setconstant, name);
6011 PUSH_LABEL(ret, lfin);
6012
6013 if (!popped) PUSH_INSN(ret, location, swap);
6014 PUSH_INSN(ret, location, pop);
6015}
6016
6021static void
6022pm_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)
6023{
6024 const pm_node_location_t location = *node_location;
6025 const pm_constant_path_node_t *target = node->target;
6026
6027 ID method_id = pm_constant_id_lookup(scope_node, node->binary_operator);
6028 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, target->name));
6029
6030 if (target->parent) {
6031 PM_COMPILE_NOT_POPPED(target->parent);
6032 }
6033 else {
6034 PUSH_INSN1(ret, location, putobject, rb_cObject);
6035 }
6036
6037 PUSH_INSN(ret, location, dup);
6038 PUSH_INSN1(ret, location, putobject, Qtrue);
6039 PUSH_INSN1(ret, location, getconstant, name);
6040
6041 if (shareability != 0) {
6042 pm_compile_shareable_constant_value(iseq, node->value, shareability, pm_constant_path_path(node->target, scope_node), ret, scope_node, true);
6043 }
6044 else {
6045 PM_COMPILE_NOT_POPPED(node->value);
6046 }
6047
6048 PUSH_CALL(ret, location, method_id, INT2FIX(1));
6049 PUSH_INSN(ret, location, swap);
6050
6051 if (!popped) {
6052 PUSH_INSN1(ret, location, topn, INT2FIX(1));
6053 PUSH_INSN(ret, location, swap);
6054 }
6055
6056 PUSH_INSN1(ret, location, setconstant, name);
6057}
6058
6065#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))
6066
6071static inline void
6072pm_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)
6073{
6074 const pm_node_location_t location = *node_location;
6075 struct rb_iseq_constant_body *body = ISEQ_BODY(iseq);
6076
6077 pm_constant_id_list_t *locals = &scope_node->locals;
6078 pm_parameters_node_t *parameters_node = NULL;
6079 pm_node_list_t *keywords_list = NULL;
6080 pm_node_list_t *optionals_list = NULL;
6081 pm_node_list_t *posts_list = NULL;
6082 pm_node_list_t *requireds_list = NULL;
6083 pm_node_list_t *block_locals = NULL;
6084 bool trailing_comma = false;
6085
6086 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE) || PM_NODE_TYPE_P(scope_node->ast_node, PM_MODULE_NODE)) {
6087 PUSH_TRACE(ret, RUBY_EVENT_CLASS);
6088 }
6089
6090 if (scope_node->parameters != NULL) {
6091 switch (PM_NODE_TYPE(scope_node->parameters)) {
6092 case PM_BLOCK_PARAMETERS_NODE: {
6093 pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) scope_node->parameters;
6094 parameters_node = cast->parameters;
6095 block_locals = &cast->locals;
6096
6097 if (parameters_node) {
6098 if (parameters_node->rest && PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE)) {
6099 trailing_comma = true;
6100 }
6101 }
6102 break;
6103 }
6104 case PM_PARAMETERS_NODE: {
6105 parameters_node = (pm_parameters_node_t *) scope_node->parameters;
6106 break;
6107 }
6108 case PM_NUMBERED_PARAMETERS_NODE: {
6109 uint32_t maximum = ((const pm_numbered_parameters_node_t *) scope_node->parameters)->maximum;
6110 body->param.lead_num = maximum;
6111 body->param.flags.ambiguous_param0 = maximum == 1;
6112 break;
6113 }
6114 case PM_IT_PARAMETERS_NODE:
6115 body->param.lead_num = 1;
6116 body->param.flags.ambiguous_param0 = true;
6117 break;
6118 default:
6119 rb_bug("Unexpected node type for parameters: %s", pm_node_type_to_str(PM_NODE_TYPE(scope_node->parameters)));
6120 }
6121 }
6122
6123 struct rb_iseq_param_keyword *keyword = NULL;
6124
6125 if (parameters_node) {
6126 optionals_list = &parameters_node->optionals;
6127 requireds_list = &parameters_node->requireds;
6128 keywords_list = &parameters_node->keywords;
6129 posts_list = &parameters_node->posts;
6130 }
6131 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))) {
6132 body->param.opt_num = 0;
6133 }
6134 else {
6135 body->param.lead_num = 0;
6136 body->param.opt_num = 0;
6137 }
6138
6139 //********STEP 1**********
6140 // Goal: calculate the table size for the locals, accounting for
6141 // hidden variables and multi target nodes
6142 size_t locals_size = locals->size;
6143
6144 // Index lookup table buffer size is only the number of the locals
6145 st_table *index_lookup_table = st_init_numtable();
6146
6147 int table_size = (int) locals_size;
6148
6149 // For nodes have a hidden iteration variable. We add that to the local
6150 // table size here.
6151 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) table_size++;
6152
6153 if (keywords_list && keywords_list->size) {
6154 table_size++;
6155 }
6156
6157 if (requireds_list) {
6158 for (size_t i = 0; i < requireds_list->size; i++) {
6159 // For each MultiTargetNode, we're going to have one
6160 // additional anonymous local not represented in the locals table
6161 // We want to account for this in our table size
6162 pm_node_t *required = requireds_list->nodes[i];
6163 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6164 table_size++;
6165 }
6166 else if (PM_NODE_TYPE_P(required, PM_REQUIRED_PARAMETER_NODE)) {
6167 if (PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6168 table_size++;
6169 }
6170 }
6171 }
6172 }
6173
6174 // If we have the `it` implicit local variable, we need to account for
6175 // it in the local table size.
6176 if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
6177 table_size++;
6178 }
6179
6180 // Ensure there is enough room in the local table for any
6181 // parameters that have been repeated
6182 // ex: def underscore_parameters(_, _ = 1, _ = 2); _; end
6183 // ^^^^^^^^^^^^
6184 if (optionals_list && optionals_list->size) {
6185 for (size_t i = 0; i < optionals_list->size; i++) {
6186 pm_node_t * node = optionals_list->nodes[i];
6187 if (PM_NODE_FLAG_P(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6188 table_size++;
6189 }
6190 }
6191 }
6192
6193 // If we have an anonymous "rest" node, we'll need to increase the local
6194 // table size to take it in to account.
6195 // def m(foo, *, bar)
6196 // ^
6197 if (parameters_node) {
6198 if (parameters_node->rest) {
6199 if (!(PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE))) {
6200 if (!((const pm_rest_parameter_node_t *) parameters_node->rest)->name || PM_NODE_FLAG_P(parameters_node->rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6201 table_size++;
6202 }
6203 }
6204 }
6205
6206 // def foo(_, **_); _; end
6207 // ^^^
6208 if (parameters_node->keyword_rest) {
6209 // def foo(...); end
6210 // ^^^
6211 // When we have a `...` as the keyword_rest, it's a forwarding_parameter_node and
6212 // we need to leave space for 4 locals: *, **, &, ...
6213 if (PM_NODE_TYPE_P(parameters_node->keyword_rest, PM_FORWARDING_PARAMETER_NODE)) {
6214 // Only optimize specifically methods like this: `foo(...)`
6215 if (requireds_list->size == 0 && optionals_list->size == 0 && keywords_list->size == 0) {
6216 ISEQ_BODY(iseq)->param.flags.use_block = TRUE;
6217 ISEQ_BODY(iseq)->param.flags.forwardable = TRUE;
6218 table_size += 1;
6219 }
6220 else {
6221 table_size += 4;
6222 }
6223 }
6224 else {
6225 const pm_keyword_rest_parameter_node_t *kw_rest = (const pm_keyword_rest_parameter_node_t *) parameters_node->keyword_rest;
6226
6227 // If it's anonymous or repeated, then we need to allocate stack space
6228 if (!kw_rest->name || PM_NODE_FLAG_P(kw_rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6229 table_size++;
6230 }
6231 }
6232 }
6233 }
6234
6235 if (posts_list) {
6236 for (size_t i = 0; i < posts_list->size; i++) {
6237 // For each MultiTargetNode, we're going to have one
6238 // additional anonymous local not represented in the locals table
6239 // We want to account for this in our table size
6240 pm_node_t *required = posts_list->nodes[i];
6241 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE) || PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6242 table_size++;
6243 }
6244 }
6245 }
6246
6247 if (keywords_list && keywords_list->size) {
6248 for (size_t i = 0; i < keywords_list->size; i++) {
6249 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6250 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6251 table_size++;
6252 }
6253 }
6254 }
6255
6256 if (parameters_node && parameters_node->block) {
6257 const pm_block_parameter_node_t *block_node = (const pm_block_parameter_node_t *) parameters_node->block;
6258
6259 if (PM_NODE_FLAG_P(block_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER) || !block_node->name) {
6260 table_size++;
6261 }
6262 }
6263
6264 // We can create local_table_for_iseq with the correct size
6265 VALUE idtmp = 0;
6266 rb_ast_id_table_t *local_table_for_iseq = ALLOCV(idtmp, sizeof(rb_ast_id_table_t) + table_size * sizeof(ID));
6267 local_table_for_iseq->size = table_size;
6268
6269 //********END OF STEP 1**********
6270
6271 //********STEP 2**********
6272 // Goal: populate iv index table as well as local table, keeping the
6273 // layout of the local table consistent with the layout of the
6274 // stack when calling the method
6275 //
6276 // Do a first pass on all of the parameters, setting their values in
6277 // the local_table_for_iseq, _except_ for Multis who get a hidden
6278 // variable in this step, and will get their names inserted in step 3
6279
6280 // local_index is a cursor that keeps track of the current
6281 // index into local_table_for_iseq. The local table is actually a list,
6282 // and the order of that list must match the order of the items pushed
6283 // on the stack. We need to take in to account things pushed on the
6284 // stack that _might not have a name_ (for example array destructuring).
6285 // This index helps us know which item we're dealing with and also give
6286 // those anonymous items temporary names (as below)
6287 int local_index = 0;
6288
6289 // Here we figure out local table indices and insert them in to the
6290 // index lookup table and local tables.
6291 //
6292 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6293 // ^^^^^^^^^^^^^
6294 if (requireds_list && requireds_list->size) {
6295 for (size_t i = 0; i < requireds_list->size; i++, local_index++) {
6296 ID local;
6297
6298 // For each MultiTargetNode, we're going to have one additional
6299 // anonymous local not represented in the locals table. We want
6300 // to account for this in our table size.
6301 pm_node_t *required = requireds_list->nodes[i];
6302
6303 switch (PM_NODE_TYPE(required)) {
6304 case PM_MULTI_TARGET_NODE: {
6305 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6306 // ^^^^^^^^^^
6307 local = rb_make_temporary_id(local_index);
6308 local_table_for_iseq->ids[local_index] = local;
6309 break;
6310 }
6311 case PM_REQUIRED_PARAMETER_NODE: {
6312 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6313 // ^
6314 const pm_required_parameter_node_t *param = (const pm_required_parameter_node_t *) required;
6315
6316 if (PM_NODE_FLAG_P(required, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6317 ID local = pm_constant_id_lookup(scope_node, param->name);
6318 local_table_for_iseq->ids[local_index] = local;
6319 }
6320 else {
6321 pm_insert_local_index(param->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6322 }
6323
6324 break;
6325 }
6326 default:
6327 rb_bug("Unsupported node in requireds in parameters %s", pm_node_type_to_str(PM_NODE_TYPE(required)));
6328 }
6329 }
6330
6331 body->param.lead_num = (int) requireds_list->size;
6332 body->param.flags.has_lead = true;
6333 }
6334
6335 if (scope_node->parameters != NULL && PM_NODE_TYPE_P(scope_node->parameters, PM_IT_PARAMETERS_NODE)) {
6336 ID local = rb_make_temporary_id(local_index);
6337 local_table_for_iseq->ids[local_index++] = local;
6338 }
6339
6340 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6341 // ^^^^^
6342 if (optionals_list && optionals_list->size) {
6343 body->param.opt_num = (int) optionals_list->size;
6344 body->param.flags.has_opt = true;
6345
6346 for (size_t i = 0; i < optionals_list->size; i++, local_index++) {
6347 pm_node_t * node = optionals_list->nodes[i];
6348 pm_constant_id_t name = ((const pm_optional_parameter_node_t *) node)->name;
6349
6350 if (PM_NODE_FLAG_P(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6351 ID local = pm_constant_id_lookup(scope_node, name);
6352 local_table_for_iseq->ids[local_index] = local;
6353 }
6354 else {
6355 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6356 }
6357 }
6358 }
6359
6360 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6361 // ^^
6362 if (parameters_node && parameters_node->rest) {
6363 body->param.rest_start = local_index;
6364
6365 // If there's a trailing comma, we'll have an implicit rest node,
6366 // and we don't want it to impact the rest variables on param
6367 if (!(PM_NODE_TYPE_P(parameters_node->rest, PM_IMPLICIT_REST_NODE))) {
6368 body->param.flags.has_rest = true;
6369 RUBY_ASSERT(body->param.rest_start != -1);
6370
6371 pm_constant_id_t name = ((const pm_rest_parameter_node_t *) parameters_node->rest)->name;
6372
6373 if (name) {
6374 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6375 // ^^
6376 if (PM_NODE_FLAG_P(parameters_node->rest, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6377 ID local = pm_constant_id_lookup(scope_node, name);
6378 local_table_for_iseq->ids[local_index] = local;
6379 }
6380 else {
6381 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6382 }
6383 }
6384 else {
6385 // def foo(a, (b, *c, d), e = 1, *, g, (h, *i, j), k:, l: 1, **m, &n)
6386 // ^
6387 body->param.flags.anon_rest = true;
6388 pm_insert_local_special(idMULT, local_index, index_lookup_table, local_table_for_iseq);
6389 }
6390
6391 local_index++;
6392 }
6393 }
6394
6395 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6396 // ^^^^^^^^^^^^^
6397 if (posts_list && posts_list->size) {
6398 body->param.post_num = (int) posts_list->size;
6399 body->param.post_start = local_index;
6400 body->param.flags.has_post = true;
6401
6402 for (size_t i = 0; i < posts_list->size; i++, local_index++) {
6403 ID local;
6404
6405 // For each MultiTargetNode, we're going to have one additional
6406 // anonymous local not represented in the locals table. We want
6407 // to account for this in our table size.
6408 const pm_node_t *post_node = posts_list->nodes[i];
6409
6410 switch (PM_NODE_TYPE(post_node)) {
6411 case PM_MULTI_TARGET_NODE: {
6412 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6413 // ^^^^^^^^^^
6414 local = rb_make_temporary_id(local_index);
6415 local_table_for_iseq->ids[local_index] = local;
6416 break;
6417 }
6418 case PM_REQUIRED_PARAMETER_NODE: {
6419 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6420 // ^
6421 const pm_required_parameter_node_t *param = (const pm_required_parameter_node_t *) post_node;
6422
6423 if (PM_NODE_FLAG_P(param, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6424 ID local = pm_constant_id_lookup(scope_node, param->name);
6425 local_table_for_iseq->ids[local_index] = local;
6426 }
6427 else {
6428 pm_insert_local_index(param->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6429 }
6430 break;
6431 }
6432 default:
6433 rb_bug("Unsupported node in posts in parameters %s", pm_node_type_to_str(PM_NODE_TYPE(post_node)));
6434 }
6435 }
6436 }
6437
6438 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6439 // ^^^^^^^^
6440 // Keywords create an internal variable on the parse tree
6441 if (keywords_list && keywords_list->size) {
6442 keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6443 keyword->num = (int) keywords_list->size;
6444
6445 const VALUE default_values = rb_ary_hidden_new(1);
6446 const VALUE complex_mark = rb_str_tmp_new(0);
6447
6448 for (size_t i = 0; i < keywords_list->size; i++) {
6449 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6450 pm_constant_id_t name;
6451
6452 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6453 // ^^
6454 if (PM_NODE_TYPE_P(keyword_parameter_node, PM_REQUIRED_KEYWORD_PARAMETER_NODE)) {
6455 name = ((const pm_required_keyword_parameter_node_t *) keyword_parameter_node)->name;
6456 keyword->required_num++;
6457 ID local = pm_constant_id_lookup(scope_node, name);
6458
6459 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6460 local_table_for_iseq->ids[local_index] = local;
6461 }
6462 else {
6463 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6464 }
6465 local_index++;
6466 }
6467 }
6468
6469 for (size_t i = 0; i < keywords_list->size; i++) {
6470 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6471 pm_constant_id_t name;
6472
6473 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6474 // ^^^^
6475 if (PM_NODE_TYPE_P(keyword_parameter_node, PM_OPTIONAL_KEYWORD_PARAMETER_NODE)) {
6476 const pm_optional_keyword_parameter_node_t *cast = ((const pm_optional_keyword_parameter_node_t *) keyword_parameter_node);
6477
6478 pm_node_t *value = cast->value;
6479 name = cast->name;
6480
6481 if (PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) && !PM_CONTAINER_P(value)) {
6482 rb_ary_push(default_values, pm_static_literal_value(iseq, value, scope_node));
6483 }
6484 else {
6485 rb_ary_push(default_values, complex_mark);
6486 }
6487
6488 ID local = pm_constant_id_lookup(scope_node, name);
6489 if (PM_NODE_FLAG_P(keyword_parameter_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6490 local_table_for_iseq->ids[local_index] = local;
6491 }
6492 else {
6493 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6494 }
6495 local_index++;
6496 }
6497
6498 }
6499
6500 if (RARRAY_LEN(default_values)) {
6501 VALUE *dvs = ALLOC_N(VALUE, RARRAY_LEN(default_values));
6502
6503 for (int i = 0; i < RARRAY_LEN(default_values); i++) {
6504 VALUE dv = RARRAY_AREF(default_values, i);
6505 if (dv == complex_mark) dv = Qundef;
6506 RB_OBJ_WRITE(iseq, &dvs[i], dv);
6507 }
6508
6509 keyword->default_values = dvs;
6510 }
6511
6512 // Hidden local for keyword arguments
6513 keyword->bits_start = local_index;
6514 ID local = rb_make_temporary_id(local_index);
6515 local_table_for_iseq->ids[local_index] = local;
6516 local_index++;
6517
6518 body->param.keyword = keyword;
6519 body->param.flags.has_kw = true;
6520 }
6521
6522 if (body->type == ISEQ_TYPE_BLOCK && local_index == 1 && requireds_list && requireds_list->size == 1 && !trailing_comma) {
6523 body->param.flags.ambiguous_param0 = true;
6524 }
6525
6526 if (parameters_node) {
6527 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6528 // ^^^
6529 if (parameters_node->keyword_rest) {
6530 switch (PM_NODE_TYPE(parameters_node->keyword_rest)) {
6531 case PM_NO_KEYWORDS_PARAMETER_NODE: {
6532 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **nil, &n)
6533 // ^^^^^
6534 body->param.flags.accepts_no_kwarg = true;
6535 break;
6536 }
6537 case PM_KEYWORD_REST_PARAMETER_NODE: {
6538 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6539 // ^^^
6540 const pm_keyword_rest_parameter_node_t *kw_rest_node = (const pm_keyword_rest_parameter_node_t *) parameters_node->keyword_rest;
6541 if (!body->param.flags.has_kw) {
6542 body->param.keyword = keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6543 }
6544
6545 keyword->rest_start = local_index;
6546 body->param.flags.has_kwrest = true;
6547
6548 pm_constant_id_t constant_id = kw_rest_node->name;
6549 if (constant_id) {
6550 if (PM_NODE_FLAG_P(kw_rest_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6551 ID local = pm_constant_id_lookup(scope_node, constant_id);
6552 local_table_for_iseq->ids[local_index] = local;
6553 }
6554 else {
6555 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6556 }
6557 }
6558 else {
6559 body->param.flags.anon_kwrest = true;
6560 pm_insert_local_special(idPow, local_index, index_lookup_table, local_table_for_iseq);
6561 }
6562
6563 local_index++;
6564 break;
6565 }
6566 case PM_FORWARDING_PARAMETER_NODE: {
6567 // def foo(...)
6568 // ^^^
6569 if (!ISEQ_BODY(iseq)->param.flags.forwardable) {
6570 // Add the anonymous *
6571 body->param.rest_start = local_index;
6572 body->param.flags.has_rest = true;
6573 body->param.flags.anon_rest = true;
6574 pm_insert_local_special(idMULT, local_index++, index_lookup_table, local_table_for_iseq);
6575
6576 // Add the anonymous **
6577 RUBY_ASSERT(!body->param.flags.has_kw);
6578 body->param.flags.has_kw = false;
6579 body->param.flags.has_kwrest = true;
6580 body->param.flags.anon_kwrest = true;
6581 body->param.keyword = keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
6582 keyword->rest_start = local_index;
6583 pm_insert_local_special(idPow, local_index++, index_lookup_table, local_table_for_iseq);
6584
6585 // Add the anonymous &
6586 body->param.block_start = local_index;
6587 body->param.flags.has_block = true;
6588 pm_insert_local_special(idAnd, local_index++, index_lookup_table, local_table_for_iseq);
6589 }
6590
6591 // Add the ...
6592 pm_insert_local_special(idDot3, local_index++, index_lookup_table, local_table_for_iseq);
6593 break;
6594 }
6595 default:
6596 rb_bug("node type %s not expected as keyword_rest", pm_node_type_to_str(PM_NODE_TYPE(parameters_node->keyword_rest)));
6597 }
6598 }
6599
6600 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6601 // ^^
6602 if (parameters_node->block) {
6603 body->param.block_start = local_index;
6604 body->param.flags.has_block = true;
6605 iseq_set_use_block(iseq);
6606
6607 pm_constant_id_t name = ((const pm_block_parameter_node_t *) parameters_node->block)->name;
6608
6609 if (name) {
6610 if (PM_NODE_FLAG_P(parameters_node->block, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6611 ID local = pm_constant_id_lookup(scope_node, name);
6612 local_table_for_iseq->ids[local_index] = local;
6613 }
6614 else {
6615 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6616 }
6617 }
6618 else {
6619 pm_insert_local_special(idAnd, local_index, index_lookup_table, local_table_for_iseq);
6620 }
6621
6622 local_index++;
6623 }
6624 }
6625
6626 //********END OF STEP 2**********
6627 // The local table is now consistent with expected
6628 // stack layout
6629
6630 // If there's only one required element in the parameters
6631 // CRuby needs to recognize it as an ambiguous parameter
6632
6633 //********STEP 3**********
6634 // Goal: fill in the names of the parameters in MultiTargetNodes
6635 //
6636 // Go through requireds again to set the multis
6637
6638 if (requireds_list && requireds_list->size) {
6639 for (size_t i = 0; i < requireds_list->size; i++) {
6640 // For each MultiTargetNode, we're going to have one
6641 // additional anonymous local not represented in the locals table
6642 // We want to account for this in our table size
6643 const pm_node_t *required = requireds_list->nodes[i];
6644
6645 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6646 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);
6647 }
6648 }
6649 }
6650
6651 // Go through posts again to set the multis
6652 if (posts_list && posts_list->size) {
6653 for (size_t i = 0; i < posts_list->size; i++) {
6654 // For each MultiTargetNode, we're going to have one
6655 // additional anonymous local not represented in the locals table
6656 // We want to account for this in our table size
6657 const pm_node_t *post = posts_list->nodes[i];
6658
6659 if (PM_NODE_TYPE_P(post, PM_MULTI_TARGET_NODE)) {
6660 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);
6661 }
6662 }
6663 }
6664
6665 // Set any anonymous locals for the for node
6666 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) {
6667 if (PM_NODE_TYPE_P(((const pm_for_node_t *) scope_node->ast_node)->index, PM_LOCAL_VARIABLE_TARGET_NODE)) {
6668 body->param.lead_num++;
6669 }
6670 else {
6671 body->param.rest_start = local_index;
6672 body->param.flags.has_rest = true;
6673 }
6674
6675 ID local = rb_make_temporary_id(local_index);
6676 local_table_for_iseq->ids[local_index] = local;
6677 local_index++;
6678 }
6679
6680 // Fill in any NumberedParameters, if they exist
6681 if (scope_node->parameters && PM_NODE_TYPE_P(scope_node->parameters, PM_NUMBERED_PARAMETERS_NODE)) {
6682 int maximum = ((const pm_numbered_parameters_node_t *) scope_node->parameters)->maximum;
6683 RUBY_ASSERT(0 < maximum && maximum <= 9);
6684 for (int i = 0; i < maximum; i++, local_index++) {
6685 const uint8_t param_name[] = { '_', '1' + i };
6686 pm_constant_id_t constant_id = pm_constant_pool_find(&scope_node->parser->constant_pool, param_name, 2);
6687 RUBY_ASSERT(constant_id && "parser should fill in any gaps in numbered parameters");
6688 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6689 }
6690 body->param.lead_num = maximum;
6691 body->param.flags.has_lead = true;
6692 }
6693
6694 //********END OF STEP 3**********
6695
6696 //********STEP 4**********
6697 // Goal: fill in the method body locals
6698 // To be explicit, these are the non-parameter locals
6699 // We fill in the block_locals, if they exist
6700 // lambda { |x; y| y }
6701 // ^
6702 if (block_locals && block_locals->size) {
6703 for (size_t i = 0; i < block_locals->size; i++, local_index++) {
6704 pm_constant_id_t constant_id = ((const pm_block_local_variable_node_t *) block_locals->nodes[i])->name;
6705 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6706 }
6707 }
6708
6709 // Fill in any locals we missed
6710 if (scope_node->locals.size) {
6711 for (size_t i = 0; i < scope_node->locals.size; i++) {
6712 pm_constant_id_t constant_id = locals->ids[i];
6713 if (constant_id) {
6714 struct pm_local_table_insert_ctx ctx;
6715 ctx.scope_node = scope_node;
6716 ctx.local_table_for_iseq = local_table_for_iseq;
6717 ctx.local_index = local_index;
6718
6719 st_update(index_lookup_table, (st_data_t)constant_id, pm_local_table_insert_func, (st_data_t)&ctx);
6720
6721 local_index = ctx.local_index;
6722 }
6723 }
6724 }
6725
6726 //********END OF STEP 4**********
6727
6728 // We set the index_lookup_table on the scope node so we can
6729 // refer to the parameters correctly
6730 if (scope_node->index_lookup_table) {
6731 st_free_table(scope_node->index_lookup_table);
6732 }
6733 scope_node->index_lookup_table = index_lookup_table;
6734 iseq_calc_param_size(iseq);
6735
6736 if (ISEQ_BODY(iseq)->param.flags.forwardable) {
6737 // We're treating `...` as a parameter so that frame
6738 // pushing won't clobber it.
6739 ISEQ_BODY(iseq)->param.size += 1;
6740 }
6741
6742 // FIXME: args?
6743 iseq_set_local_table(iseq, local_table_for_iseq, 0);
6744 scope_node->local_table_for_iseq_size = local_table_for_iseq->size;
6745
6746 if (keyword != NULL) {
6747 size_t keyword_start_index = keyword->bits_start - keyword->num;
6748 keyword->table = (ID *)&ISEQ_BODY(iseq)->local_table[keyword_start_index];
6749 }
6750
6751 //********STEP 5************
6752 // Goal: compile anything that needed to be compiled
6753 if (optionals_list && optionals_list->size) {
6754 LABEL **opt_table = (LABEL **) ALLOC_N(VALUE, optionals_list->size + 1);
6755 LABEL *label;
6756
6757 // TODO: Should we make an api for NEW_LABEL where you can pass
6758 // a pointer to the label it should fill out? We already
6759 // have a list of labels allocated above so it seems wasteful
6760 // to do the copies.
6761 for (size_t i = 0; i < optionals_list->size; i++) {
6762 label = NEW_LABEL(location.line);
6763 opt_table[i] = label;
6764 PUSH_LABEL(ret, label);
6765 pm_node_t *optional_node = optionals_list->nodes[i];
6766 PM_COMPILE_NOT_POPPED(optional_node);
6767 }
6768
6769 // Set the last label
6770 label = NEW_LABEL(location.line);
6771 opt_table[optionals_list->size] = label;
6772 PUSH_LABEL(ret, label);
6773
6774 body->param.opt_table = (const VALUE *) opt_table;
6775 }
6776
6777 if (keywords_list && keywords_list->size) {
6778 size_t optional_index = 0;
6779 for (size_t i = 0; i < keywords_list->size; i++) {
6780 pm_node_t *keyword_parameter_node = keywords_list->nodes[i];
6781 pm_constant_id_t name;
6782
6783 switch (PM_NODE_TYPE(keyword_parameter_node)) {
6784 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
6785 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6786 // ^^^^
6787 const pm_optional_keyword_parameter_node_t *cast = ((const pm_optional_keyword_parameter_node_t *) keyword_parameter_node);
6788
6789 pm_node_t *value = cast->value;
6790 name = cast->name;
6791
6792 if (!PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) || PM_CONTAINER_P(value)) {
6793 LABEL *end_label = NEW_LABEL(location.line);
6794
6795 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, name, 0);
6796 int kw_bits_idx = table_size - body->param.keyword->bits_start;
6797 PUSH_INSN2(ret, location, checkkeyword, INT2FIX(kw_bits_idx + VM_ENV_DATA_SIZE - 1), INT2FIX(optional_index));
6798 PUSH_INSNL(ret, location, branchif, end_label);
6799 PM_COMPILE(value);
6800 PUSH_SETLOCAL(ret, location, index.index, index.level);
6801 PUSH_LABEL(ret, end_label);
6802 }
6803 optional_index++;
6804 break;
6805 }
6806 case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
6807 // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
6808 // ^^
6809 break;
6810 default:
6811 rb_bug("Unexpected keyword parameter node type %s", pm_node_type_to_str(PM_NODE_TYPE(keyword_parameter_node)));
6812 }
6813 }
6814 }
6815
6816 if (requireds_list && requireds_list->size) {
6817 for (size_t i = 0; i < requireds_list->size; i++) {
6818 // For each MultiTargetNode, we're going to have one additional
6819 // anonymous local not represented in the locals table. We want
6820 // to account for this in our table size.
6821 const pm_node_t *required = requireds_list->nodes[i];
6822
6823 if (PM_NODE_TYPE_P(required, PM_MULTI_TARGET_NODE)) {
6824 PUSH_GETLOCAL(ret, location, table_size - (int)i, 0);
6825 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) required, ret, scope_node);
6826 }
6827 }
6828 }
6829
6830 if (posts_list && posts_list->size) {
6831 for (size_t i = 0; i < posts_list->size; i++) {
6832 // For each MultiTargetNode, we're going to have one additional
6833 // anonymous local not represented in the locals table. We want
6834 // to account for this in our table size.
6835 const pm_node_t *post = posts_list->nodes[i];
6836
6837 if (PM_NODE_TYPE_P(post, PM_MULTI_TARGET_NODE)) {
6838 PUSH_GETLOCAL(ret, location, table_size - body->param.post_start - (int) i, 0);
6839 pm_compile_destructured_param_writes(iseq, (const pm_multi_target_node_t *) post, ret, scope_node);
6840 }
6841 }
6842 }
6843
6844 switch (body->type) {
6845 case ISEQ_TYPE_PLAIN: {
6846 RUBY_ASSERT(PM_NODE_TYPE_P(scope_node->ast_node, PM_INTERPOLATED_REGULAR_EXPRESSION_NODE));
6847
6848 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) scope_node->ast_node;
6849 pm_compile_regexp_dynamic(iseq, (const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6850
6851 break;
6852 }
6853 case ISEQ_TYPE_BLOCK: {
6854 LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
6855 LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
6856 const pm_node_location_t block_location = { .line = body->location.first_lineno, .node_id = scope_node->ast_node->node_id };
6857
6858 start->rescued = LABEL_RESCUE_BEG;
6859 end->rescued = LABEL_RESCUE_END;
6860
6861 // For nodes automatically assign the iteration variable to whatever
6862 // index variable. We need to handle that write here because it has
6863 // to happen in the context of the block. Note that this happens
6864 // before the B_CALL tracepoint event.
6865 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_FOR_NODE)) {
6866 pm_compile_for_node_index(iseq, ((const pm_for_node_t *) scope_node->ast_node)->index, ret, scope_node);
6867 }
6868
6869 PUSH_TRACE(ret, RUBY_EVENT_B_CALL);
6870 PUSH_INSN(ret, block_location, nop);
6871 PUSH_LABEL(ret, start);
6872
6873 if (scope_node->body != NULL) {
6874 switch (PM_NODE_TYPE(scope_node->ast_node)) {
6875 case PM_POST_EXECUTION_NODE: {
6876 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) scope_node->ast_node;
6877 PUSH_INSN1(ret, block_location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6878
6879 // We create another ScopeNode from the statements within the PostExecutionNode
6880 pm_scope_node_t next_scope_node;
6881 pm_scope_node_init((const pm_node_t *) cast->statements, &next_scope_node, scope_node);
6882
6883 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(body->parent_iseq), ISEQ_TYPE_BLOCK, location.line);
6884 pm_scope_node_destroy(&next_scope_node);
6885
6886 PUSH_CALL_WITH_BLOCK(ret, block_location, id_core_set_postexe, INT2FIX(0), block);
6887 break;
6888 }
6889 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
6890 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) scope_node->ast_node;
6891 pm_compile_regexp_dynamic(iseq, (const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6892 break;
6893 }
6894 default:
6895 pm_compile_node(iseq, scope_node->body, ret, popped, scope_node);
6896 break;
6897 }
6898 }
6899 else {
6900 PUSH_INSN(ret, block_location, putnil);
6901 }
6902
6903 PUSH_LABEL(ret, end);
6904 PUSH_TRACE(ret, RUBY_EVENT_B_RETURN);
6905 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6906
6907 /* wide range catch handler must put at last */
6908 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start);
6909 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end);
6910 break;
6911 }
6912 case ISEQ_TYPE_ENSURE: {
6913 const pm_node_location_t statements_location = (scope_node->body != NULL ? PM_NODE_START_LOCATION(scope_node->parser, scope_node->body) : location);
6914 iseq_set_exception_local_table(iseq);
6915
6916 if (scope_node->body != NULL) {
6917 PM_COMPILE_POPPED((const pm_node_t *) scope_node->body);
6918 }
6919
6920 PUSH_GETLOCAL(ret, statements_location, 1, 0);
6921 PUSH_INSN1(ret, statements_location, throw, INT2FIX(0));
6922 return;
6923 }
6924 case ISEQ_TYPE_METHOD: {
6925 ISEQ_COMPILE_DATA(iseq)->root_node = (const void *) scope_node->body;
6926 PUSH_TRACE(ret, RUBY_EVENT_CALL);
6927
6928 if (scope_node->body) {
6929 PM_COMPILE((const pm_node_t *) scope_node->body);
6930 }
6931 else {
6932 PUSH_INSN(ret, location, putnil);
6933 }
6934
6935 ISEQ_COMPILE_DATA(iseq)->root_node = (const void *) scope_node->body;
6936 PUSH_TRACE(ret, RUBY_EVENT_RETURN);
6937
6938 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6939 break;
6940 }
6941 case ISEQ_TYPE_RESCUE: {
6942 iseq_set_exception_local_table(iseq);
6943 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_RESCUE_MODIFIER_NODE)) {
6944 LABEL *lab = NEW_LABEL(location.line);
6945 LABEL *rescue_end = NEW_LABEL(location.line);
6946 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
6947 PUSH_INSN1(ret, location, putobject, rb_eStandardError);
6948 PUSH_INSN1(ret, location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
6949 PUSH_INSNL(ret, location, branchif, lab);
6950 PUSH_INSNL(ret, location, jump, rescue_end);
6951 PUSH_LABEL(ret, lab);
6952 PUSH_TRACE(ret, RUBY_EVENT_RESCUE);
6953 PM_COMPILE((const pm_node_t *) scope_node->body);
6954 PUSH_INSN(ret, location, leave);
6955 PUSH_LABEL(ret, rescue_end);
6956 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
6957 }
6958 else {
6959 PM_COMPILE((const pm_node_t *) scope_node->ast_node);
6960 }
6961 PUSH_INSN1(ret, location, throw, INT2FIX(0));
6962
6963 return;
6964 }
6965 default:
6966 if (scope_node->body) {
6967 PM_COMPILE((const pm_node_t *) scope_node->body);
6968 }
6969 else {
6970 PUSH_INSN(ret, location, putnil);
6971 }
6972 break;
6973 }
6974
6975 if (PM_NODE_TYPE_P(scope_node->ast_node, PM_CLASS_NODE) || PM_NODE_TYPE_P(scope_node->ast_node, PM_MODULE_NODE)) {
6976 const pm_node_location_t end_location = PM_NODE_END_LOCATION(scope_node->parser, scope_node->ast_node);
6977 PUSH_TRACE(ret, RUBY_EVENT_END);
6978 ISEQ_COMPILE_DATA(iseq)->last_line = end_location.line;
6979 }
6980
6981 if (!PM_NODE_TYPE_P(scope_node->ast_node, PM_ENSURE_NODE)) {
6982 const pm_node_location_t location = { .line = ISEQ_COMPILE_DATA(iseq)->last_line, .node_id = scope_node->ast_node->node_id };
6983 PUSH_INSN(ret, location, leave);
6984 }
6985}
6986
6987static inline void
6988pm_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)
6989{
6990 // alias $foo $bar
6991 // ^^^^^^^^^^^^^^^
6992 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6993
6994 {
6995 const pm_location_t *name_loc = &node->new_name->location;
6996 VALUE operand = ID2SYM(rb_intern3((const char *) name_loc->start, name_loc->end - name_loc->start, scope_node->encoding));
6997 PUSH_INSN1(ret, *location, putobject, operand);
6998 }
6999
7000 {
7001 const pm_location_t *name_loc = &node->old_name->location;
7002 VALUE operand = ID2SYM(rb_intern3((const char *) name_loc->start, name_loc->end - name_loc->start, scope_node->encoding));
7003 PUSH_INSN1(ret, *location, putobject, operand);
7004 }
7005
7006 PUSH_SEND(ret, *location, id_core_set_variable_alias, INT2FIX(2));
7007 if (popped) PUSH_INSN(ret, *location, pop);
7008}
7009
7010static inline void
7011pm_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)
7012{
7013 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7014 PUSH_INSN1(ret, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
7015 PM_COMPILE_NOT_POPPED(node->new_name);
7016 PM_COMPILE_NOT_POPPED(node->old_name);
7017
7018 PUSH_SEND(ret, *location, id_core_set_method_alias, INT2FIX(3));
7019 if (popped) PUSH_INSN(ret, *location, pop);
7020}
7021
7022static inline void
7023pm_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)
7024{
7025 LABEL *end_label = NEW_LABEL(location->line);
7026
7027 PM_COMPILE_NOT_POPPED(node->left);
7028 if (!popped) PUSH_INSN(ret, *location, dup);
7029 PUSH_INSNL(ret, *location, branchunless, end_label);
7030
7031 if (!popped) PUSH_INSN(ret, *location, pop);
7032 PM_COMPILE(node->right);
7033 PUSH_LABEL(ret, end_label);
7034}
7035
7036static inline void
7037pm_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)
7038{
7039 // If every node in the array is static, then we can compile the entire
7040 // array now instead of later.
7041 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
7042 // We're only going to compile this node if it's not popped. If it
7043 // is popped, then we know we don't need to do anything since it's
7044 // statically known.
7045 if (!popped) {
7046 if (elements->size) {
7047 VALUE value = pm_static_literal_value(iseq, node, scope_node);
7048 PUSH_INSN1(ret, *location, duparray, value);
7049 }
7050 else {
7051 PUSH_INSN1(ret, *location, newarray, INT2FIX(0));
7052 }
7053 }
7054 return;
7055 }
7056
7057 // Here since we know there are possible side-effects inside the
7058 // array contents, we're going to build it entirely at runtime.
7059 // We'll do this by pushing all of the elements onto the stack and
7060 // then combining them with newarray.
7061 //
7062 // If this array is popped, then this serves only to ensure we enact
7063 // all side-effects (like method calls) that are contained within
7064 // the array contents.
7065 //
7066 // We treat all sequences of non-splat elements as their
7067 // own arrays, followed by a newarray, and then continually
7068 // concat the arrays with the SplatNode nodes.
7069 const int max_new_array_size = 0x100;
7070 const unsigned int min_tmp_array_size = 0x40;
7071
7072 int new_array_size = 0;
7073 bool first_chunk = true;
7074
7075 // This is an optimization wherein we keep track of whether or not
7076 // the previous element was a static literal. If it was, then we do
7077 // not attempt to check if we have a subarray that can be optimized.
7078 // If it was not, then we do check.
7079 bool static_literal = false;
7080
7081 // Either create a new array, or push to the existing array.
7082#define FLUSH_CHUNK \
7083 if (new_array_size) { \
7084 if (first_chunk) PUSH_INSN1(ret, *location, newarray, INT2FIX(new_array_size)); \
7085 else PUSH_INSN1(ret, *location, pushtoarray, INT2FIX(new_array_size)); \
7086 first_chunk = false; \
7087 new_array_size = 0; \
7088 }
7089
7090 for (size_t index = 0; index < elements->size; index++) {
7091 const pm_node_t *element = elements->nodes[index];
7092
7093 if (PM_NODE_TYPE_P(element, PM_SPLAT_NODE)) {
7094 FLUSH_CHUNK;
7095
7096 const pm_splat_node_t *splat_element = (const pm_splat_node_t *) element;
7097 if (splat_element->expression) {
7098 PM_COMPILE_NOT_POPPED(splat_element->expression);
7099 }
7100 else {
7101 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
7102 PUSH_GETLOCAL(ret, *location, index.index, index.level);
7103 }
7104
7105 if (first_chunk) {
7106 // If this is the first element of the array then we
7107 // need to splatarray the elements into the list.
7108 PUSH_INSN1(ret, *location, splatarray, Qtrue);
7109 first_chunk = false;
7110 }
7111 else {
7112 PUSH_INSN(ret, *location, concattoarray);
7113 }
7114
7115 static_literal = false;
7116 }
7117 else if (PM_NODE_TYPE_P(element, PM_KEYWORD_HASH_NODE)) {
7118 if (new_array_size == 0 && first_chunk) {
7119 PUSH_INSN1(ret, *location, newarray, INT2FIX(0));
7120 first_chunk = false;
7121 }
7122 else {
7123 FLUSH_CHUNK;
7124 }
7125
7126 // If we get here, then this is the last element of the
7127 // array/arguments, because it cannot be followed by
7128 // anything else without a syntax error. This looks like:
7129 //
7130 // [foo, bar, baz: qux]
7131 // ^^^^^^^^
7132 //
7133 // [foo, bar, **baz]
7134 // ^^^^^
7135 //
7136 const pm_keyword_hash_node_t *keyword_hash = (const pm_keyword_hash_node_t *) element;
7137 pm_compile_hash_elements(iseq, element, &keyword_hash->elements, 0, Qundef, false, ret, scope_node);
7138
7139 // This boolean controls the manner in which we push the
7140 // hash onto the array. If it's all keyword splats, then we
7141 // can use the very specialized pushtoarraykwsplat
7142 // instruction to check if it's empty before we push it.
7143 size_t splats = 0;
7144 while (splats < keyword_hash->elements.size && PM_NODE_TYPE_P(keyword_hash->elements.nodes[splats], PM_ASSOC_SPLAT_NODE)) splats++;
7145
7146 if (keyword_hash->elements.size == splats) {
7147 PUSH_INSN(ret, *location, pushtoarraykwsplat);
7148 }
7149 else {
7150 new_array_size++;
7151 }
7152 }
7153 else if (
7154 PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL) &&
7155 !PM_CONTAINER_P(element) &&
7156 !static_literal &&
7157 ((index + min_tmp_array_size) < elements->size)
7158 ) {
7159 // If we have a static literal, then there's the potential
7160 // to group a bunch of them together with a literal array
7161 // and then concat them together.
7162 size_t right_index = index + 1;
7163 while (
7164 right_index < elements->size &&
7165 PM_NODE_FLAG_P(elements->nodes[right_index], PM_NODE_FLAG_STATIC_LITERAL) &&
7166 !PM_CONTAINER_P(elements->nodes[right_index])
7167 ) right_index++;
7168
7169 size_t tmp_array_size = right_index - index;
7170 if (tmp_array_size >= min_tmp_array_size) {
7171 VALUE tmp_array = rb_ary_hidden_new(tmp_array_size);
7172
7173 // Create the temporary array.
7174 for (; tmp_array_size; tmp_array_size--)
7175 rb_ary_push(tmp_array, pm_static_literal_value(iseq, elements->nodes[index++], scope_node));
7176
7177 index--; // about to be incremented by for loop
7178 OBJ_FREEZE(tmp_array);
7179
7180 // Emit the optimized code.
7181 FLUSH_CHUNK;
7182 if (first_chunk) {
7183 PUSH_INSN1(ret, *location, duparray, tmp_array);
7184 first_chunk = false;
7185 }
7186 else {
7187 PUSH_INSN1(ret, *location, putobject, tmp_array);
7188 PUSH_INSN(ret, *location, concattoarray);
7189 }
7190 }
7191 else {
7192 PM_COMPILE_NOT_POPPED(element);
7193 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7194 static_literal = true;
7195 }
7196 } else {
7197 PM_COMPILE_NOT_POPPED(element);
7198 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7199 static_literal = false;
7200 }
7201 }
7202
7203 FLUSH_CHUNK;
7204 if (popped) PUSH_INSN(ret, *location, pop);
7205
7206#undef FLUSH_CHUNK
7207}
7208
7209static inline void
7210pm_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)
7211{
7212 unsigned long throw_flag = 0;
7213
7214 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
7215 /* while/until */
7216 LABEL *splabel = NEW_LABEL(0);
7217 PUSH_LABEL(ret, splabel);
7218 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
7219
7220 if (node->arguments != NULL) {
7221 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
7222 }
7223 else {
7224 PUSH_INSN(ret, *location, putnil);
7225 }
7226
7227 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7228 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
7229 PUSH_ADJUST_RESTORE(ret, splabel);
7230 if (!popped) PUSH_INSN(ret, *location, putnil);
7231 }
7232 else {
7233 const rb_iseq_t *ip = iseq;
7234
7235 while (ip) {
7236 if (!ISEQ_COMPILE_DATA(ip)) {
7237 ip = 0;
7238 break;
7239 }
7240
7241 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
7242 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
7243 }
7244 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
7245 throw_flag = 0;
7246 }
7247 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
7248 COMPILE_ERROR(iseq, location->line, "Invalid break");
7249 return;
7250 }
7251 else {
7252 ip = ISEQ_BODY(ip)->parent_iseq;
7253 continue;
7254 }
7255
7256 /* escape from block */
7257 if (node->arguments != NULL) {
7258 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
7259 }
7260 else {
7261 PUSH_INSN(ret, *location, putnil);
7262 }
7263
7264 PUSH_INSN1(ret, *location, throw, INT2FIX(throw_flag | TAG_BREAK));
7265 if (popped) PUSH_INSN(ret, *location, pop);
7266
7267 return;
7268 }
7269
7270 COMPILE_ERROR(iseq, location->line, "Invalid break");
7271 }
7272}
7273
7274static inline void
7275pm_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)
7276{
7277 ID method_id = pm_constant_id_lookup(scope_node, node->name);
7278
7279 const pm_location_t *message_loc = &node->message_loc;
7280 if (message_loc->start == NULL) message_loc = &node->base.location;
7281
7282 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, message_loc, node->base.node_id);
7283 const char *builtin_func;
7284
7285 if (UNLIKELY(iseq_has_builtin_function_table(iseq)) && (builtin_func = pm_iseq_builtin_function_name(scope_node, node->receiver, method_id)) != NULL) {
7286 pm_compile_builtin_function_call(iseq, ret, scope_node, node, &location, popped, ISEQ_COMPILE_DATA(iseq)->current_block, builtin_func);
7287 return;
7288 }
7289
7290 LABEL *start = NEW_LABEL(location.line);
7291 if (node->block) PUSH_LABEL(ret, start);
7292
7293 switch (method_id) {
7294 case idUMinus: {
7295 if (pm_opt_str_freeze_p(iseq, node)) {
7296 VALUE value = parse_static_literal_string(iseq, scope_node, node->receiver, &((const pm_string_node_t * ) node->receiver)->unescaped);
7297 const struct rb_callinfo *callinfo = new_callinfo(iseq, idUMinus, 0, 0, NULL, FALSE);
7298 PUSH_INSN2(ret, location, opt_str_uminus, value, callinfo);
7299 if (popped) PUSH_INSN(ret, location, pop);
7300 return;
7301 }
7302 break;
7303 }
7304 case idFreeze: {
7305 if (pm_opt_str_freeze_p(iseq, node)) {
7306 VALUE value = parse_static_literal_string(iseq, scope_node, node->receiver, &((const pm_string_node_t * ) node->receiver)->unescaped);
7307 const struct rb_callinfo *callinfo = new_callinfo(iseq, idFreeze, 0, 0, NULL, FALSE);
7308 PUSH_INSN2(ret, location, opt_str_freeze, value, callinfo);
7309 if (popped) PUSH_INSN(ret, location, pop);
7310 return;
7311 }
7312 break;
7313 }
7314 case idAREF: {
7315 if (pm_opt_aref_with_p(iseq, node)) {
7316 const pm_string_node_t *string = (const pm_string_node_t *) ((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0];
7317 VALUE value = parse_static_literal_string(iseq, scope_node, (const pm_node_t *) string, &string->unescaped);
7318
7319 PM_COMPILE_NOT_POPPED(node->receiver);
7320
7321 const struct rb_callinfo *callinfo = new_callinfo(iseq, idAREF, 1, 0, NULL, FALSE);
7322 PUSH_INSN2(ret, location, opt_aref_with, value, callinfo);
7323
7324 if (popped) {
7325 PUSH_INSN(ret, location, pop);
7326 }
7327
7328 return;
7329 }
7330 break;
7331 }
7332 case idASET: {
7333 if (pm_opt_aset_with_p(iseq, node)) {
7334 const pm_string_node_t *string = (const pm_string_node_t *) ((const pm_arguments_node_t *) node->arguments)->arguments.nodes[0];
7335 VALUE value = parse_static_literal_string(iseq, scope_node, (const pm_node_t *) string, &string->unescaped);
7336
7337 PM_COMPILE_NOT_POPPED(node->receiver);
7338 PM_COMPILE_NOT_POPPED(((const pm_arguments_node_t *) node->arguments)->arguments.nodes[1]);
7339
7340 if (!popped) {
7341 PUSH_INSN(ret, location, swap);
7342 PUSH_INSN1(ret, location, topn, INT2FIX(1));
7343 }
7344
7345 const struct rb_callinfo *callinfo = new_callinfo(iseq, idASET, 2, 0, NULL, FALSE);
7346 PUSH_INSN2(ret, location, opt_aset_with, value, callinfo);
7347 PUSH_INSN(ret, location, pop);
7348 return;
7349 }
7350 break;
7351 }
7352 }
7353
7354 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) && !popped) {
7355 PUSH_INSN(ret, location, putnil);
7356 }
7357
7358 if (node->receiver == NULL) {
7359 PUSH_INSN(ret, location, putself);
7360 }
7361 else {
7362 if (method_id == idCall && PM_NODE_TYPE_P(node->receiver, PM_LOCAL_VARIABLE_READ_NODE)) {
7363 const pm_local_variable_read_node_t *read_node_cast = (const pm_local_variable_read_node_t *) node->receiver;
7364 uint32_t node_id = node->receiver->node_id;
7365 int idx, level;
7366
7367 if (iseq_block_param_id_p(iseq, pm_constant_id_lookup(scope_node, read_node_cast->name), &idx, &level)) {
7368 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)));
7369 }
7370 else {
7371 PM_COMPILE_NOT_POPPED(node->receiver);
7372 }
7373 }
7374 else {
7375 PM_COMPILE_NOT_POPPED(node->receiver);
7376 }
7377 }
7378
7379 pm_compile_call(iseq, node, ret, popped, scope_node, method_id, start);
7380 return;
7381}
7382
7383static inline void
7384pm_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)
7385{
7386 int flag = 0;
7387
7388 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
7389 flag = VM_CALL_FCALL;
7390 }
7391
7392 PM_COMPILE_NOT_POPPED(node->receiver);
7393
7394 LABEL *safe_label = NULL;
7395 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
7396 safe_label = NEW_LABEL(location->line);
7397 PUSH_INSN(ret, *location, dup);
7398 PUSH_INSNL(ret, *location, branchnil, safe_label);
7399 }
7400
7401 PUSH_INSN(ret, *location, dup);
7402
7403 ID id_read_name = pm_constant_id_lookup(scope_node, node->read_name);
7404 PUSH_SEND_WITH_FLAG(ret, *location, id_read_name, INT2FIX(0), INT2FIX(flag));
7405
7406 PM_COMPILE_NOT_POPPED(node->value);
7407 ID id_operator = pm_constant_id_lookup(scope_node, node->binary_operator);
7408 PUSH_SEND(ret, *location, id_operator, INT2FIX(1));
7409
7410 if (!popped) {
7411 PUSH_INSN(ret, *location, swap);
7412 PUSH_INSN1(ret, *location, topn, INT2FIX(1));
7413 }
7414
7415 ID id_write_name = pm_constant_id_lookup(scope_node, node->write_name);
7416 PUSH_SEND_WITH_FLAG(ret, *location, id_write_name, INT2FIX(1), INT2FIX(flag));
7417
7418 if (safe_label != NULL && popped) PUSH_LABEL(ret, safe_label);
7419 PUSH_INSN(ret, *location, pop);
7420 if (safe_label != NULL && !popped) PUSH_LABEL(ret, safe_label);
7421}
7422
7439static VALUE
7440pm_compile_case_node_dispatch(rb_iseq_t *iseq, VALUE dispatch, const pm_node_t *node, LABEL *label, const pm_scope_node_t *scope_node)
7441{
7442 VALUE key = Qundef;
7443
7444 switch (PM_NODE_TYPE(node)) {
7445 case PM_FLOAT_NODE: {
7446 key = pm_static_literal_value(iseq, node, scope_node);
7447 double intptr;
7448
7449 if (modf(RFLOAT_VALUE(key), &intptr) == 0.0) {
7450 key = (FIXABLE(intptr) ? LONG2FIX((long) intptr) : rb_dbl2big(intptr));
7451 }
7452
7453 break;
7454 }
7455 case PM_FALSE_NODE:
7456 case PM_INTEGER_NODE:
7457 case PM_NIL_NODE:
7458 case PM_SOURCE_FILE_NODE:
7459 case PM_SOURCE_LINE_NODE:
7460 case PM_SYMBOL_NODE:
7461 case PM_TRUE_NODE:
7462 key = pm_static_literal_value(iseq, node, scope_node);
7463 break;
7464 case PM_STRING_NODE: {
7465 const pm_string_node_t *cast = (const pm_string_node_t *) node;
7466 key = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
7467 break;
7468 }
7469 default:
7470 return Qundef;
7471 }
7472
7473 if (NIL_P(rb_hash_lookup(dispatch, key))) {
7474 rb_hash_aset(dispatch, key, ((VALUE) label) | 1);
7475 }
7476
7477 return dispatch;
7478}
7479
7483static inline void
7484pm_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)
7485{
7486 const pm_parser_t *parser = scope_node->parser;
7487 const pm_node_location_t location = *node_location;
7488 const pm_node_list_t *conditions = &cast->conditions;
7489
7490 // This is the anchor that we will compile the conditions of the various
7491 // `when` nodes into. If a match is found, they will need to jump into
7492 // the body_seq anchor to the correct spot.
7493 DECL_ANCHOR(cond_seq);
7494
7495 // This is the anchor that we will compile the bodies of the various
7496 // `when` nodes into. We'll make sure that the clauses that are compiled
7497 // jump into the correct spots within this anchor.
7498 DECL_ANCHOR(body_seq);
7499
7500 // This is the label where all of the when clauses will jump to if they
7501 // have matched and are done executing their bodies.
7502 LABEL *end_label = NEW_LABEL(location.line);
7503
7504 // If we have a predicate on this case statement, then it's going to
7505 // compare all of the various when clauses to the predicate. If we
7506 // don't, then it's basically an if-elsif-else chain.
7507 if (cast->predicate == NULL) {
7508 // Establish branch coverage for the case node.
7509 VALUE branches = Qfalse;
7510 rb_code_location_t case_location = { 0 };
7511 int branch_id = 0;
7512
7513 if (PM_BRANCH_COVERAGE_P(iseq)) {
7514 case_location = pm_code_location(scope_node, (const pm_node_t *) cast);
7515 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location, "case");
7516 }
7517
7518 // Loop through each clauses in the case node and compile each of
7519 // the conditions within them into cond_seq. If they match, they
7520 // should jump into their respective bodies in body_seq.
7521 for (size_t clause_index = 0; clause_index < conditions->size; clause_index++) {
7522 const pm_when_node_t *clause = (const pm_when_node_t *) conditions->nodes[clause_index];
7523 const pm_node_list_t *conditions = &clause->conditions;
7524
7525 int clause_lineno = pm_node_line_number(parser, (const pm_node_t *) clause);
7526 LABEL *label = NEW_LABEL(clause_lineno);
7527 PUSH_LABEL(body_seq, label);
7528
7529 // Establish branch coverage for the when clause.
7530 if (PM_BRANCH_COVERAGE_P(iseq)) {
7531 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));
7532 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "when", branches);
7533 }
7534
7535 if (clause->statements != NULL) {
7536 pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7537 }
7538 else if (!popped) {
7539 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7540 }
7541
7542 PUSH_INSNL(body_seq, location, jump, end_label);
7543
7544 // Compile each of the conditions for the when clause into the
7545 // cond_seq. Each one should have a unique condition and should
7546 // jump to the subsequent one if it doesn't match.
7547 for (size_t condition_index = 0; condition_index < conditions->size; condition_index++) {
7548 const pm_node_t *condition = conditions->nodes[condition_index];
7549
7550 if (PM_NODE_TYPE_P(condition, PM_SPLAT_NODE)) {
7551 pm_node_location_t cond_location = PM_NODE_START_LOCATION(parser, condition);
7552 PUSH_INSN(cond_seq, cond_location, putnil);
7553 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7554 PUSH_INSN1(cond_seq, cond_location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_WHEN | VM_CHECKMATCH_ARRAY));
7555 PUSH_INSNL(cond_seq, cond_location, branchif, label);
7556 }
7557 else {
7558 LABEL *next_label = NEW_LABEL(pm_node_line_number(parser, condition));
7559 pm_compile_branch_condition(iseq, cond_seq, condition, label, next_label, false, scope_node);
7560 PUSH_LABEL(cond_seq, next_label);
7561 }
7562 }
7563 }
7564
7565 // Establish branch coverage for the else clause (implicit or
7566 // explicit).
7567 if (PM_BRANCH_COVERAGE_P(iseq)) {
7568 rb_code_location_t branch_location;
7569
7570 if (cast->else_clause == NULL) {
7571 branch_location = case_location;
7572 } else if (cast->else_clause->statements == NULL) {
7573 branch_location = pm_code_location(scope_node, (const pm_node_t *) cast->else_clause);
7574 } else {
7575 branch_location = pm_code_location(scope_node, (const pm_node_t *) cast->else_clause->statements);
7576 }
7577
7578 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7579 }
7580
7581 // Compile the else clause if there is one.
7582 if (cast->else_clause != NULL) {
7583 pm_compile_node(iseq, (const pm_node_t *) cast->else_clause, cond_seq, popped, scope_node);
7584 }
7585 else if (!popped) {
7586 PUSH_SYNTHETIC_PUTNIL(cond_seq, iseq);
7587 }
7588
7589 // Finally, jump to the end label if none of the other conditions
7590 // have matched.
7591 PUSH_INSNL(cond_seq, location, jump, end_label);
7592 PUSH_SEQ(ret, cond_seq);
7593 }
7594 else {
7595 // Establish branch coverage for the case node.
7596 VALUE branches = Qfalse;
7597 rb_code_location_t case_location = { 0 };
7598 int branch_id = 0;
7599
7600 if (PM_BRANCH_COVERAGE_P(iseq)) {
7601 case_location = pm_code_location(scope_node, (const pm_node_t *) cast);
7602 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location, "case");
7603 }
7604
7605 // This is the label where everything will fall into if none of the
7606 // conditions matched.
7607 LABEL *else_label = NEW_LABEL(location.line);
7608
7609 // It's possible for us to speed up the case node by using a
7610 // dispatch hash. This is a hash that maps the conditions of the
7611 // various when clauses to the labels of their bodies. If we can
7612 // compile the conditions into a hash key, then we can use a hash
7613 // lookup to jump directly to the correct when clause body.
7614 VALUE dispatch = Qundef;
7615 if (ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction) {
7616 dispatch = rb_hash_new();
7617 RHASH_TBL_RAW(dispatch)->type = &cdhash_type;
7618 }
7619
7620 // We're going to loop through each of the conditions in the case
7621 // node and compile each of their contents into both the cond_seq
7622 // and the body_seq. Each condition will use its own label to jump
7623 // from its conditions into its body.
7624 //
7625 // Note that none of the code in the loop below should be adding
7626 // anything to ret, as we're going to be laying out the entire case
7627 // node instructions later.
7628 for (size_t clause_index = 0; clause_index < conditions->size; clause_index++) {
7629 const pm_when_node_t *clause = (const pm_when_node_t *) conditions->nodes[clause_index];
7630 pm_node_location_t clause_location = PM_NODE_START_LOCATION(parser, (const pm_node_t *) clause);
7631
7632 const pm_node_list_t *conditions = &clause->conditions;
7633 LABEL *label = NEW_LABEL(clause_location.line);
7634
7635 // Compile each of the conditions for the when clause into the
7636 // cond_seq. Each one should have a unique comparison that then
7637 // jumps into the body if it matches.
7638 for (size_t condition_index = 0; condition_index < conditions->size; condition_index++) {
7639 const pm_node_t *condition = conditions->nodes[condition_index];
7640 const pm_node_location_t condition_location = PM_NODE_START_LOCATION(parser, condition);
7641
7642 // If we haven't already abandoned the optimization, then
7643 // we're going to try to compile the condition into the
7644 // dispatch hash.
7645 if (dispatch != Qundef) {
7646 dispatch = pm_compile_case_node_dispatch(iseq, dispatch, condition, label, scope_node);
7647 }
7648
7649 if (PM_NODE_TYPE_P(condition, PM_SPLAT_NODE)) {
7650 PUSH_INSN(cond_seq, condition_location, dup);
7651 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7652 PUSH_INSN1(cond_seq, condition_location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_CASE | VM_CHECKMATCH_ARRAY));
7653 }
7654 else {
7655 if (PM_NODE_TYPE_P(condition, PM_STRING_NODE)) {
7656 const pm_string_node_t *string = (const pm_string_node_t *) condition;
7657 VALUE value = parse_static_literal_string(iseq, scope_node, condition, &string->unescaped);
7658 PUSH_INSN1(cond_seq, condition_location, putobject, value);
7659 }
7660 else {
7661 pm_compile_node(iseq, condition, cond_seq, false, scope_node);
7662 }
7663
7664 PUSH_INSN1(cond_seq, condition_location, topn, INT2FIX(1));
7665 PUSH_SEND_WITH_FLAG(cond_seq, condition_location, idEqq, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
7666 }
7667
7668 PUSH_INSNL(cond_seq, condition_location, branchif, label);
7669 }
7670
7671 // Now, add the label to the body and compile the body of the
7672 // when clause. This involves popping the predicate, compiling
7673 // the statements to be executed, and then compiling a jump to
7674 // the end of the case node.
7675 PUSH_LABEL(body_seq, label);
7676 PUSH_INSN(body_seq, clause_location, pop);
7677
7678 // Establish branch coverage for the when clause.
7679 if (PM_BRANCH_COVERAGE_P(iseq)) {
7680 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));
7681 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "when", branches);
7682 }
7683
7684 if (clause->statements != NULL) {
7685 pm_compile_node(iseq, (const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7686 }
7687 else if (!popped) {
7688 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7689 }
7690
7691 PUSH_INSNL(body_seq, clause_location, jump, end_label);
7692 }
7693
7694 // Now that we have compiled the conditions and the bodies of the
7695 // various when clauses, we can compile the predicate, lay out the
7696 // conditions, compile the fallback subsequent if there is one, and
7697 // finally put in the bodies of the when clauses.
7698 PM_COMPILE_NOT_POPPED(cast->predicate);
7699
7700 // If we have a dispatch hash, then we'll use it here to create the
7701 // optimization.
7702 if (dispatch != Qundef) {
7703 PUSH_INSN(ret, location, dup);
7704 PUSH_INSN2(ret, location, opt_case_dispatch, dispatch, else_label);
7705 LABEL_REF(else_label);
7706 }
7707
7708 PUSH_SEQ(ret, cond_seq);
7709
7710 // Compile either the explicit else clause or an implicit else
7711 // clause.
7712 PUSH_LABEL(ret, else_label);
7713
7714 if (cast->else_clause != NULL) {
7715 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));
7716 PUSH_INSN(ret, else_location, pop);
7717
7718 // Establish branch coverage for the else clause.
7719 if (PM_BRANCH_COVERAGE_P(iseq)) {
7720 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));
7721 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7722 }
7723
7724 PM_COMPILE((const pm_node_t *) cast->else_clause);
7725 PUSH_INSNL(ret, else_location, jump, end_label);
7726 }
7727 else {
7728 PUSH_INSN(ret, location, pop);
7729
7730 // Establish branch coverage for the implicit else clause.
7731 if (PM_BRANCH_COVERAGE_P(iseq)) {
7732 add_trace_branch_coverage(iseq, ret, &case_location, case_location.beg_pos.column, branch_id, "else", branches);
7733 }
7734
7735 if (!popped) PUSH_INSN(ret, location, putnil);
7736 PUSH_INSNL(ret, location, jump, end_label);
7737 }
7738 }
7739
7740 PUSH_SEQ(ret, body_seq);
7741 PUSH_LABEL(ret, end_label);
7742}
7743
7744static inline void
7745pm_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)
7746{
7747 // This is the anchor that we will compile the bodies of the various
7748 // `in` nodes into. We'll make sure that the patterns that are compiled
7749 // jump into the correct spots within this anchor.
7750 DECL_ANCHOR(body_seq);
7751
7752 // This is the anchor that we will compile the patterns of the various
7753 // `in` nodes into. If a match is found, they will need to jump into the
7754 // body_seq anchor to the correct spot.
7755 DECL_ANCHOR(cond_seq);
7756
7757 // This label is used to indicate the end of the entire node. It is
7758 // jumped to after the entire stack is cleaned up.
7759 LABEL *end_label = NEW_LABEL(location->line);
7760
7761 // This label is used as the fallback for the case match. If no match is
7762 // found, then we jump to this label. This is either an `else` clause or
7763 // an error handler.
7764 LABEL *else_label = NEW_LABEL(location->line);
7765
7766 // We're going to use this to uniquely identify each branch so that we
7767 // can track coverage information.
7768 rb_code_location_t case_location = { 0 };
7769 VALUE branches = Qfalse;
7770 int branch_id = 0;
7771
7772 if (PM_BRANCH_COVERAGE_P(iseq)) {
7773 case_location = pm_code_location(scope_node, (const pm_node_t *) node);
7774 branches = decl_branch_base(iseq, PTR2NUM(node), &case_location, "case");
7775 }
7776
7777 // If there is only one pattern, then the behavior changes a bit. It
7778 // effectively gets treated as a match required node (this is how it is
7779 // represented in the other parser).
7780 bool in_single_pattern = node->else_clause == NULL && node->conditions.size == 1;
7781
7782 // First, we're going to push a bunch of stuff onto the stack that is
7783 // going to serve as our scratch space.
7784 if (in_single_pattern) {
7785 PUSH_INSN(ret, *location, putnil); // key error key
7786 PUSH_INSN(ret, *location, putnil); // key error matchee
7787 PUSH_INSN1(ret, *location, putobject, Qfalse); // key error?
7788 PUSH_INSN(ret, *location, putnil); // error string
7789 }
7790
7791 // Now we're going to compile the value to match against.
7792 PUSH_INSN(ret, *location, putnil); // deconstruct cache
7793 PM_COMPILE_NOT_POPPED(node->predicate);
7794
7795 // Next, we'll loop through every in clause and compile its body into
7796 // the body_seq anchor and its pattern into the cond_seq anchor. We'll
7797 // make sure the pattern knows how to jump correctly into the body if it
7798 // finds a match.
7799 for (size_t index = 0; index < node->conditions.size; index++) {
7800 const pm_node_t *condition = node->conditions.nodes[index];
7801 RUBY_ASSERT(PM_NODE_TYPE_P(condition, PM_IN_NODE));
7802
7803 const pm_in_node_t *in_node = (const pm_in_node_t *) condition;
7804 const pm_node_location_t in_location = PM_NODE_START_LOCATION(scope_node->parser, in_node);
7805 const pm_node_location_t pattern_location = PM_NODE_START_LOCATION(scope_node->parser, in_node->pattern);
7806
7807 if (branch_id) {
7808 PUSH_INSN(body_seq, in_location, putnil);
7809 }
7810
7811 LABEL *body_label = NEW_LABEL(in_location.line);
7812 PUSH_LABEL(body_seq, body_label);
7813 PUSH_INSN1(body_seq, in_location, adjuststack, INT2FIX(in_single_pattern ? 6 : 2));
7814
7815 // Establish branch coverage for the in clause.
7816 if (PM_BRANCH_COVERAGE_P(iseq)) {
7817 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));
7818 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++, "in", branches);
7819 }
7820
7821 if (in_node->statements != NULL) {
7822 PM_COMPILE_INTO_ANCHOR(body_seq, (const pm_node_t *) in_node->statements);
7823 }
7824 else if (!popped) {
7825 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7826 }
7827
7828 PUSH_INSNL(body_seq, in_location, jump, end_label);
7829 LABEL *next_pattern_label = NEW_LABEL(pattern_location.line);
7830
7831 PUSH_INSN(cond_seq, pattern_location, dup);
7832 pm_compile_pattern(iseq, scope_node, in_node->pattern, cond_seq, body_label, next_pattern_label, in_single_pattern, false, true, 2);
7833 PUSH_LABEL(cond_seq, next_pattern_label);
7834 LABEL_UNREMOVABLE(next_pattern_label);
7835 }
7836
7837 if (node->else_clause != NULL) {
7838 // If we have an `else` clause, then this becomes our fallback (and
7839 // there is no need to compile in code to potentially raise an
7840 // error).
7841 const pm_else_node_t *else_node = node->else_clause;
7842
7843 PUSH_LABEL(cond_seq, else_label);
7844 PUSH_INSN(cond_seq, *location, pop);
7845 PUSH_INSN(cond_seq, *location, pop);
7846
7847 // Establish branch coverage for the else clause.
7848 if (PM_BRANCH_COVERAGE_P(iseq)) {
7849 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));
7850 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id, "else", branches);
7851 }
7852
7853 PM_COMPILE_INTO_ANCHOR(cond_seq, (const pm_node_t *) else_node);
7854 PUSH_INSNL(cond_seq, *location, jump, end_label);
7855 PUSH_INSN(cond_seq, *location, putnil);
7856 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7857 }
7858 else {
7859 // Otherwise, if we do not have an `else` clause, we will compile in
7860 // the code to handle raising an appropriate error.
7861 PUSH_LABEL(cond_seq, else_label);
7862
7863 // Establish branch coverage for the implicit else clause.
7864 add_trace_branch_coverage(iseq, cond_seq, &case_location, case_location.beg_pos.column, branch_id, "else", branches);
7865
7866 if (in_single_pattern) {
7867 pm_compile_pattern_error_handler(iseq, scope_node, (const pm_node_t *) node, cond_seq, end_label, popped);
7868 }
7869 else {
7870 PUSH_INSN1(cond_seq, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7871 PUSH_INSN1(cond_seq, *location, putobject, rb_eNoMatchingPatternError);
7872 PUSH_INSN1(cond_seq, *location, topn, INT2FIX(2));
7873 PUSH_SEND(cond_seq, *location, id_core_raise, INT2FIX(2));
7874
7875 PUSH_INSN1(cond_seq, *location, adjuststack, INT2FIX(3));
7876 if (!popped) PUSH_INSN(cond_seq, *location, putnil);
7877 PUSH_INSNL(cond_seq, *location, jump, end_label);
7878 PUSH_INSN1(cond_seq, *location, dupn, INT2FIX(1));
7879 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7880 }
7881 }
7882
7883 // At the end of all of this compilation, we will add the code for the
7884 // conditions first, then the various bodies, then mark the end of the
7885 // entire sequence with the end label.
7886 PUSH_SEQ(ret, cond_seq);
7887 PUSH_SEQ(ret, body_seq);
7888 PUSH_LABEL(ret, end_label);
7889}
7890
7891static inline void
7892pm_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)
7893{
7894 const rb_iseq_t *block = NULL;
7895 const rb_iseq_t *previous_block = NULL;
7896 LABEL *retry_label = NULL;
7897 LABEL *retry_end_l = NULL;
7898
7899 if (node->block != NULL) {
7900 previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
7901 ISEQ_COMPILE_DATA(iseq)->current_block = NULL;
7902
7903 retry_label = NEW_LABEL(location->line);
7904 retry_end_l = NEW_LABEL(location->line);
7905
7906 PUSH_LABEL(ret, retry_label);
7907 }
7908 else {
7909 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
7910 }
7911
7912 PUSH_INSN(ret, *location, putself);
7913 int flag = VM_CALL_ZSUPER | VM_CALL_SUPER | VM_CALL_FCALL;
7914
7915 if (node->block != NULL) {
7916 pm_scope_node_t next_scope_node;
7917 pm_scope_node_init((const pm_node_t *) node->block, &next_scope_node, scope_node);
7918
7919 ISEQ_COMPILE_DATA(iseq)->current_block = block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->line);
7920 pm_scope_node_destroy(&next_scope_node);
7921 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) block);
7922 }
7923
7924 DECL_ANCHOR(args);
7925
7926 struct rb_iseq_constant_body *const body = ISEQ_BODY(iseq);
7927 const rb_iseq_t *local_iseq = body->local_iseq;
7928 const struct rb_iseq_constant_body *const local_body = ISEQ_BODY(local_iseq);
7929
7930 int argc = 0;
7931 int depth = get_lvar_level(iseq);
7932
7933 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
7934 flag |= VM_CALL_FORWARDING;
7935 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
7936 PUSH_GETLOCAL(ret, *location, mult_local.index, mult_local.level);
7937
7938 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, 0, flag, NULL, block != NULL);
7939 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, block);
7940
7941 if (popped) PUSH_INSN(ret, *location, pop);
7942 if (node->block) {
7943 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
7944 }
7945 return;
7946 }
7947
7948 if (local_body->param.flags.has_lead) {
7949 /* required arguments */
7950 for (int i = 0; i < local_body->param.lead_num; i++) {
7951 int idx = local_body->local_table_size - i;
7952 PUSH_GETLOCAL(args, *location, idx, depth);
7953 }
7954 argc += local_body->param.lead_num;
7955 }
7956
7957 if (local_body->param.flags.has_opt) {
7958 /* optional arguments */
7959 for (int j = 0; j < local_body->param.opt_num; j++) {
7960 int idx = local_body->local_table_size - (argc + j);
7961 PUSH_GETLOCAL(args, *location, idx, depth);
7962 }
7963 argc += local_body->param.opt_num;
7964 }
7965
7966 if (local_body->param.flags.has_rest) {
7967 /* rest argument */
7968 int idx = local_body->local_table_size - local_body->param.rest_start;
7969 PUSH_GETLOCAL(args, *location, idx, depth);
7970 PUSH_INSN1(args, *location, splatarray, Qfalse);
7971
7972 argc = local_body->param.rest_start + 1;
7973 flag |= VM_CALL_ARGS_SPLAT;
7974 }
7975
7976 if (local_body->param.flags.has_post) {
7977 /* post arguments */
7978 int post_len = local_body->param.post_num;
7979 int post_start = local_body->param.post_start;
7980
7981 int j = 0;
7982 for (; j < post_len; j++) {
7983 int idx = local_body->local_table_size - (post_start + j);
7984 PUSH_GETLOCAL(args, *location, idx, depth);
7985 }
7986
7987 if (local_body->param.flags.has_rest) {
7988 // argc remains unchanged from rest branch
7989 PUSH_INSN1(args, *location, newarray, INT2FIX(j));
7990 PUSH_INSN(args, *location, concatarray);
7991 }
7992 else {
7993 argc = post_len + post_start;
7994 }
7995 }
7996
7997 const struct rb_iseq_param_keyword *const local_keyword = local_body->param.keyword;
7998 if (local_body->param.flags.has_kw) {
7999 int local_size = local_body->local_table_size;
8000 argc++;
8001
8002 PUSH_INSN1(args, *location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
8003
8004 if (local_body->param.flags.has_kwrest) {
8005 int idx = local_body->local_table_size - local_keyword->rest_start;
8006 PUSH_GETLOCAL(args, *location, idx, depth);
8007 RUBY_ASSERT(local_keyword->num > 0);
8008 PUSH_SEND(args, *location, rb_intern("dup"), INT2FIX(0));
8009 }
8010 else {
8011 PUSH_INSN1(args, *location, newhash, INT2FIX(0));
8012 }
8013 int i = 0;
8014 for (; i < local_keyword->num; ++i) {
8015 ID id = local_keyword->table[i];
8016 int idx = local_size - get_local_var_idx(local_iseq, id);
8017
8018 {
8019 VALUE operand = ID2SYM(id);
8020 PUSH_INSN1(args, *location, putobject, operand);
8021 }
8022
8023 PUSH_GETLOCAL(args, *location, idx, depth);
8024 }
8025
8026 PUSH_SEND(args, *location, id_core_hash_merge_ptr, INT2FIX(i * 2 + 1));
8027 flag |= VM_CALL_KW_SPLAT| VM_CALL_KW_SPLAT_MUT;
8028 }
8029 else if (local_body->param.flags.has_kwrest) {
8030 int idx = local_body->local_table_size - local_keyword->rest_start;
8031 PUSH_GETLOCAL(args, *location, idx, depth);
8032 argc++;
8033 flag |= VM_CALL_KW_SPLAT;
8034 }
8035
8036 PUSH_SEQ(ret, args);
8037
8038 {
8039 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flag, NULL, block != NULL);
8040 PUSH_INSN2(ret, *location, invokesuper, callinfo, block);
8041 }
8042
8043 if (node->block != NULL) {
8044 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8045 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, block, retry_end_l);
8046 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8047 }
8048
8049 if (popped) PUSH_INSN(ret, *location, pop);
8050}
8051
8052static inline void
8053pm_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)
8054{
8055 LABEL *matched_label = NEW_LABEL(location->line);
8056 LABEL *unmatched_label = NEW_LABEL(location->line);
8057 LABEL *done_label = NEW_LABEL(location->line);
8058
8059 // First, we're going to push a bunch of stuff onto the stack that is
8060 // going to serve as our scratch space.
8061 PUSH_INSN(ret, *location, putnil); // key error key
8062 PUSH_INSN(ret, *location, putnil); // key error matchee
8063 PUSH_INSN1(ret, *location, putobject, Qfalse); // key error?
8064 PUSH_INSN(ret, *location, putnil); // error string
8065 PUSH_INSN(ret, *location, putnil); // deconstruct cache
8066
8067 // Next we're going to compile the value expression such that it's on
8068 // the stack.
8069 PM_COMPILE_NOT_POPPED(node->value);
8070
8071 // Here we'll dup it so that it can be used for comparison, but also be
8072 // used for error handling.
8073 PUSH_INSN(ret, *location, dup);
8074
8075 // Next we'll compile the pattern. We indicate to the pm_compile_pattern
8076 // function that this is the only pattern that will be matched against
8077 // through the in_single_pattern parameter. We also indicate that the
8078 // value to compare against is 2 slots from the top of the stack (the
8079 // base_index parameter).
8080 pm_compile_pattern(iseq, scope_node, node->pattern, ret, matched_label, unmatched_label, true, false, true, 2);
8081
8082 // If the pattern did not match the value, then we're going to compile
8083 // in our error handler code. This will determine which error to raise
8084 // and raise it.
8085 PUSH_LABEL(ret, unmatched_label);
8086 pm_compile_pattern_error_handler(iseq, scope_node, (const pm_node_t *) node, ret, done_label, popped);
8087
8088 // If the pattern did match, we'll clean up the values we've pushed onto
8089 // the stack and then push nil onto the stack if it's not popped.
8090 PUSH_LABEL(ret, matched_label);
8091 PUSH_INSN1(ret, *location, adjuststack, INT2FIX(6));
8092 if (!popped) PUSH_INSN(ret, *location, putnil);
8093 PUSH_INSNL(ret, *location, jump, done_label);
8094
8095 PUSH_LABEL(ret, done_label);
8096}
8097
8098static inline void
8099pm_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)
8100{
8101 LABEL *fail_label = NEW_LABEL(location->line);
8102 LABEL *end_label = NEW_LABEL(location->line);
8103
8104 // First, we'll compile the call so that all of its instructions are
8105 // present. Then we'll compile all of the local variable targets.
8106 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->call);
8107
8108 // Now, check if the match was successful. If it was, then we'll
8109 // continue on and assign local variables. Otherwise we'll skip over the
8110 // assignment code.
8111 {
8112 VALUE operand = rb_id2sym(idBACKREF);
8113 PUSH_INSN1(ret, *location, getglobal, operand);
8114 }
8115
8116 PUSH_INSN(ret, *location, dup);
8117 PUSH_INSNL(ret, *location, branchunless, fail_label);
8118
8119 // If there's only a single local variable target, we can skip some of
8120 // the bookkeeping, so we'll put a special branch here.
8121 size_t targets_count = node->targets.size;
8122
8123 if (targets_count == 1) {
8124 const pm_node_t *target = node->targets.nodes[0];
8125 RUBY_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_TARGET_NODE));
8126
8127 const pm_local_variable_target_node_t *local_target = (const pm_local_variable_target_node_t *) target;
8128 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->name, local_target->depth);
8129
8130 {
8131 VALUE operand = rb_id2sym(pm_constant_id_lookup(scope_node, local_target->name));
8132 PUSH_INSN1(ret, *location, putobject, operand);
8133 }
8134
8135 PUSH_SEND(ret, *location, idAREF, INT2FIX(1));
8136 PUSH_LABEL(ret, fail_label);
8137 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8138 if (popped) PUSH_INSN(ret, *location, pop);
8139 return;
8140 }
8141
8142 DECL_ANCHOR(fail_anchor);
8143
8144 // Otherwise there is more than one local variable target, so we'll need
8145 // to do some bookkeeping.
8146 for (size_t targets_index = 0; targets_index < targets_count; targets_index++) {
8147 const pm_node_t *target = node->targets.nodes[targets_index];
8148 RUBY_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_TARGET_NODE));
8149
8150 const pm_local_variable_target_node_t *local_target = (const pm_local_variable_target_node_t *) target;
8151 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->name, local_target->depth);
8152
8153 if (((size_t) targets_index) < (targets_count - 1)) {
8154 PUSH_INSN(ret, *location, dup);
8155 }
8156
8157 {
8158 VALUE operand = rb_id2sym(pm_constant_id_lookup(scope_node, local_target->name));
8159 PUSH_INSN1(ret, *location, putobject, operand);
8160 }
8161
8162 PUSH_SEND(ret, *location, idAREF, INT2FIX(1));
8163 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8164
8165 PUSH_INSN(fail_anchor, *location, putnil);
8166 PUSH_SETLOCAL(fail_anchor, *location, index.index, index.level);
8167 }
8168
8169 // Since we matched successfully, now we'll jump to the end.
8170 PUSH_INSNL(ret, *location, jump, end_label);
8171
8172 // In the case that the match failed, we'll loop through each local
8173 // variable target and set all of them to `nil`.
8174 PUSH_LABEL(ret, fail_label);
8175 PUSH_INSN(ret, *location, pop);
8176 PUSH_SEQ(ret, fail_anchor);
8177
8178 // Finally, we can push the end label for either case.
8179 PUSH_LABEL(ret, end_label);
8180 if (popped) PUSH_INSN(ret, *location, pop);
8181}
8182
8183static inline void
8184pm_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)
8185{
8186 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
8187 LABEL *splabel = NEW_LABEL(0);
8188 PUSH_LABEL(ret, splabel);
8189
8190 if (node->arguments) {
8191 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8192 }
8193 else {
8194 PUSH_INSN(ret, *location, putnil);
8195 }
8196 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8197
8198 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8199 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8200
8201 PUSH_ADJUST_RESTORE(ret, splabel);
8202 if (!popped) PUSH_INSN(ret, *location, putnil);
8203 }
8204 else if (ISEQ_COMPILE_DATA(iseq)->end_label && can_add_ensure_iseq(iseq)) {
8205 LABEL *splabel = NEW_LABEL(0);
8206
8207 PUSH_LABEL(ret, splabel);
8208 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8209
8210 if (node->arguments != NULL) {
8211 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8212 }
8213 else {
8214 PUSH_INSN(ret, *location, putnil);
8215 }
8216
8217 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8218 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
8219 PUSH_ADJUST_RESTORE(ret, splabel);
8220 splabel->unremovable = FALSE;
8221
8222 if (!popped) PUSH_INSN(ret, *location, putnil);
8223 }
8224 else {
8225 const rb_iseq_t *ip = iseq;
8226 unsigned long throw_flag = 0;
8227
8228 while (ip) {
8229 if (!ISEQ_COMPILE_DATA(ip)) {
8230 ip = 0;
8231 break;
8232 }
8233
8234 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
8235 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8236 /* while loop */
8237 break;
8238 }
8239 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
8240 break;
8241 }
8242 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
8243 COMPILE_ERROR(iseq, location->line, "Invalid next");
8244 return;
8245 }
8246
8247 ip = ISEQ_BODY(ip)->parent_iseq;
8248 }
8249
8250 if (ip != 0) {
8251 if (node->arguments) {
8252 PM_COMPILE_NOT_POPPED((const pm_node_t *) node->arguments);
8253 }
8254 else {
8255 PUSH_INSN(ret, *location, putnil);
8256 }
8257
8258 PUSH_INSN1(ret, *location, throw, INT2FIX(throw_flag | TAG_NEXT));
8259 if (popped) PUSH_INSN(ret, *location, pop);
8260 }
8261 else {
8262 COMPILE_ERROR(iseq, location->line, "Invalid next");
8263 }
8264 }
8265}
8266
8267static inline void
8268pm_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)
8269{
8270 if (ISEQ_COMPILE_DATA(iseq)->redo_label && can_add_ensure_iseq(iseq)) {
8271 LABEL *splabel = NEW_LABEL(0);
8272
8273 PUSH_LABEL(ret, splabel);
8274 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8275 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8276
8277 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->redo_label);
8278 PUSH_ADJUST_RESTORE(ret, splabel);
8279 if (!popped) PUSH_INSN(ret, *location, putnil);
8280 }
8281 else if (ISEQ_BODY(iseq)->type != ISEQ_TYPE_EVAL && ISEQ_COMPILE_DATA(iseq)->start_label && can_add_ensure_iseq(iseq)) {
8282 LABEL *splabel = NEW_LABEL(0);
8283
8284 PUSH_LABEL(ret, splabel);
8285 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8286 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8287
8288 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8289 PUSH_ADJUST_RESTORE(ret, splabel);
8290 if (!popped) PUSH_INSN(ret, *location, putnil);
8291 }
8292 else {
8293 const rb_iseq_t *ip = iseq;
8294
8295 while (ip) {
8296 if (!ISEQ_COMPILE_DATA(ip)) {
8297 ip = 0;
8298 break;
8299 }
8300
8301 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8302 break;
8303 }
8304 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_BLOCK) {
8305 break;
8306 }
8307 else if (ISEQ_BODY(ip)->type == ISEQ_TYPE_EVAL) {
8308 COMPILE_ERROR(iseq, location->line, "Invalid redo");
8309 return;
8310 }
8311
8312 ip = ISEQ_BODY(ip)->parent_iseq;
8313 }
8314
8315 if (ip != 0) {
8316 PUSH_INSN(ret, *location, putnil);
8317 PUSH_INSN1(ret, *location, throw, INT2FIX(VM_THROW_NO_ESCAPE_FLAG | TAG_REDO));
8318 if (popped) PUSH_INSN(ret, *location, pop);
8319 }
8320 else {
8321 COMPILE_ERROR(iseq, location->line, "Invalid redo");
8322 }
8323 }
8324}
8325
8326static inline void
8327pm_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)
8328{
8329 iseq_set_exception_local_table(iseq);
8330
8331 // First, establish the labels that we need to be able to jump to within
8332 // this compilation block.
8333 LABEL *exception_match_label = NEW_LABEL(location->line);
8334 LABEL *rescue_end_label = NEW_LABEL(location->line);
8335
8336 // Next, compile each of the exceptions that we're going to be
8337 // handling. For each one, we'll add instructions to check if the
8338 // exception matches the raised one, and if it does then jump to the
8339 // exception_match_label label. Otherwise it will fall through to the
8340 // subsequent check. If there are no exceptions, we'll only check
8341 // StandardError.
8342 const pm_node_list_t *exceptions = &node->exceptions;
8343
8344 if (exceptions->size > 0) {
8345 for (size_t index = 0; index < exceptions->size; index++) {
8346 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8347 PM_COMPILE(exceptions->nodes[index]);
8348 int checkmatch_flags = VM_CHECKMATCH_TYPE_RESCUE;
8349 if (PM_NODE_TYPE_P(exceptions->nodes[index], PM_SPLAT_NODE)) {
8350 checkmatch_flags |= VM_CHECKMATCH_ARRAY;
8351 }
8352 PUSH_INSN1(ret, *location, checkmatch, INT2FIX(checkmatch_flags));
8353 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8354 }
8355 }
8356 else {
8357 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8358 PUSH_INSN1(ret, *location, putobject, rb_eStandardError);
8359 PUSH_INSN1(ret, *location, checkmatch, INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
8360 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8361 }
8362
8363 // If none of the exceptions that we are matching against matched, then
8364 // we'll jump straight to the rescue_end_label label.
8365 PUSH_INSNL(ret, *location, jump, rescue_end_label);
8366
8367 // Here we have the exception_match_label, which is where the
8368 // control-flow goes in the case that one of the exceptions matched.
8369 // Here we will compile the instructions to handle the exception.
8370 PUSH_LABEL(ret, exception_match_label);
8371 PUSH_TRACE(ret, RUBY_EVENT_RESCUE);
8372
8373 // If we have a reference to the exception, then we'll compile the write
8374 // into the instruction sequence. This can look quite different
8375 // depending on the kind of write being performed.
8376 if (node->reference) {
8377 DECL_ANCHOR(writes);
8378 DECL_ANCHOR(cleanup);
8379
8380 pm_compile_target_node(iseq, node->reference, ret, writes, cleanup, scope_node, NULL);
8381 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8382
8383 PUSH_SEQ(ret, writes);
8384 PUSH_SEQ(ret, cleanup);
8385 }
8386
8387 // If we have statements to execute, we'll compile them here. Otherwise
8388 // we'll push nil onto the stack.
8389 if (node->statements != NULL) {
8390 // We'll temporarily remove the end_label location from the iseq
8391 // when compiling the statements so that next/redo statements
8392 // inside the body will throw to the correct place instead of
8393 // jumping straight to the end of this iseq
8394 LABEL *prev_end = ISEQ_COMPILE_DATA(iseq)->end_label;
8395 ISEQ_COMPILE_DATA(iseq)->end_label = NULL;
8396
8397 PM_COMPILE((const pm_node_t *) node->statements);
8398
8399 // Now restore the end_label
8400 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end;
8401 }
8402 else {
8403 PUSH_INSN(ret, *location, putnil);
8404 }
8405
8406 PUSH_INSN(ret, *location, leave);
8407
8408 // Here we'll insert the rescue_end_label label, which is jumped to if
8409 // none of the exceptions matched. It will cause the control-flow to
8410 // either jump to the next rescue clause or it will fall through to the
8411 // subsequent instruction returning the raised error.
8412 PUSH_LABEL(ret, rescue_end_label);
8413 if (node->subsequent != NULL) {
8414 PM_COMPILE((const pm_node_t *) node->subsequent);
8415 }
8416 else {
8417 PUSH_GETLOCAL(ret, *location, 1, 0);
8418 }
8419}
8420
8421static inline void
8422pm_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)
8423{
8424 const pm_arguments_node_t *arguments = node->arguments;
8425 enum rb_iseq_type type = ISEQ_BODY(iseq)->type;
8426 LABEL *splabel = 0;
8427
8428 const rb_iseq_t *parent_iseq = iseq;
8429 enum rb_iseq_type parent_type = ISEQ_BODY(parent_iseq)->type;
8430 while (parent_type == ISEQ_TYPE_RESCUE || parent_type == ISEQ_TYPE_ENSURE) {
8431 if (!(parent_iseq = ISEQ_BODY(parent_iseq)->parent_iseq)) break;
8432 parent_type = ISEQ_BODY(parent_iseq)->type;
8433 }
8434
8435 switch (parent_type) {
8436 case ISEQ_TYPE_TOP:
8437 case ISEQ_TYPE_MAIN:
8438 if (arguments) {
8439 rb_warn("argument of top-level return is ignored");
8440 }
8441 if (parent_iseq == iseq) {
8442 type = ISEQ_TYPE_METHOD;
8443 }
8444 break;
8445 default:
8446 break;
8447 }
8448
8449 if (type == ISEQ_TYPE_METHOD) {
8450 splabel = NEW_LABEL(0);
8451 PUSH_LABEL(ret, splabel);
8452 PUSH_ADJUST(ret, *location, 0);
8453 }
8454
8455 if (arguments != NULL) {
8456 PM_COMPILE_NOT_POPPED((const pm_node_t *) arguments);
8457 }
8458 else {
8459 PUSH_INSN(ret, *location, putnil);
8460 }
8461
8462 if (type == ISEQ_TYPE_METHOD && can_add_ensure_iseq(iseq)) {
8463 pm_add_ensure_iseq(ret, iseq, 1, scope_node);
8464 PUSH_TRACE(ret, RUBY_EVENT_RETURN);
8465 PUSH_INSN(ret, *location, leave);
8466 PUSH_ADJUST_RESTORE(ret, splabel);
8467 if (!popped) PUSH_INSN(ret, *location, putnil);
8468 }
8469 else {
8470 PUSH_INSN1(ret, *location, throw, INT2FIX(TAG_RETURN));
8471 if (popped) PUSH_INSN(ret, *location, pop);
8472 }
8473}
8474
8475static inline void
8476pm_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)
8477{
8478 DECL_ANCHOR(args);
8479
8480 LABEL *retry_label = NEW_LABEL(location->line);
8481 LABEL *retry_end_l = NEW_LABEL(location->line);
8482
8483 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
8484 const rb_iseq_t *current_block;
8485 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NULL;
8486
8487 PUSH_LABEL(ret, retry_label);
8488 PUSH_INSN(ret, *location, putself);
8489
8490 int flags = 0;
8491 struct rb_callinfo_kwarg *keywords = NULL;
8492 int argc = pm_setup_args(node->arguments, node->block, &flags, &keywords, iseq, ret, scope_node, location);
8493 bool is_forwardable = (node->arguments != NULL) && PM_NODE_FLAG_P(node->arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING);
8494 flags |= VM_CALL_SUPER | VM_CALL_FCALL;
8495
8496 if (node->block && PM_NODE_TYPE_P(node->block, PM_BLOCK_NODE)) {
8497 pm_scope_node_t next_scope_node;
8498 pm_scope_node_init(node->block, &next_scope_node, scope_node);
8499
8500 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->line);
8501 pm_scope_node_destroy(&next_scope_node);
8502 }
8503
8504 if (!node->block) {
8505 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8506 }
8507
8508 if ((flags & VM_CALL_ARGS_BLOCKARG) && (flags & VM_CALL_KW_SPLAT) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
8509 PUSH_INSN(args, *location, splatkw);
8510 }
8511
8512 PUSH_SEQ(ret, args);
8513 if (is_forwardable && ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
8514 flags |= VM_CALL_FORWARDING;
8515
8516 {
8517 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8518 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, current_block);
8519 }
8520 }
8521 else {
8522 {
8523 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8524 PUSH_INSN2(ret, *location, invokesuper, callinfo, current_block);
8525 }
8526
8527 }
8528
8529 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8530
8531 if (popped) PUSH_INSN(ret, *location, pop);
8532 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8533 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, current_block, retry_end_l);
8534}
8535
8536static inline void
8537pm_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)
8538{
8539 switch (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->type) {
8540 case ISEQ_TYPE_TOP:
8541 case ISEQ_TYPE_MAIN:
8542 case ISEQ_TYPE_CLASS:
8543 COMPILE_ERROR(iseq, location->line, "Invalid yield");
8544 return;
8545 default: /* valid */;
8546 }
8547
8548 int argc = 0;
8549 int flags = 0;
8550 struct rb_callinfo_kwarg *keywords = NULL;
8551
8552 if (node->arguments) {
8553 argc = pm_setup_args(node->arguments, NULL, &flags, &keywords, iseq, ret, scope_node, location);
8554 }
8555
8556 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, FALSE);
8557 PUSH_INSN1(ret, *location, invokeblock, callinfo);
8558
8559 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8560 if (popped) PUSH_INSN(ret, *location, pop);
8561
8562 int level = 0;
8563 for (const rb_iseq_t *tmp_iseq = iseq; tmp_iseq != ISEQ_BODY(iseq)->local_iseq; level++) {
8564 tmp_iseq = ISEQ_BODY(tmp_iseq)->parent_iseq;
8565 }
8566
8567 if (level > 0) access_outer_variables(iseq, level, rb_intern("yield"), true);
8568}
8569
8580static void
8581pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret, bool popped, pm_scope_node_t *scope_node)
8582{
8583 const pm_parser_t *parser = scope_node->parser;
8584 const pm_node_location_t location = PM_NODE_START_LOCATION(parser, node);
8585 int lineno = (int) location.line;
8586
8587 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)) {
8588 // If this node is a begin node and it has empty statements and also
8589 // has a rescue clause, then the other parser considers it as
8590 // starting on the same line as the rescue, as opposed to the
8591 // location of the begin keyword. We replicate that behavior here.
8592 lineno = (int) PM_NODE_START_LINE_COLUMN(parser, ((const pm_begin_node_t *) node)->rescue_clause).line;
8593 }
8594
8595 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_NEWLINE) && ISEQ_COMPILE_DATA(iseq)->last_line != lineno) {
8596 // If this node has the newline flag set and it is on a new line
8597 // from the previous nodes that have been compiled for this ISEQ,
8598 // then we need to emit a newline event.
8599 int event = RUBY_EVENT_LINE;
8600
8601 ISEQ_COMPILE_DATA(iseq)->last_line = lineno;
8602 if (lineno > 0 && ISEQ_COVERAGE(iseq) && ISEQ_LINE_COVERAGE(iseq)) {
8603 event |= RUBY_EVENT_COVERAGE_LINE;
8604 }
8605 PUSH_TRACE(ret, event);
8606 }
8607
8608 switch (PM_NODE_TYPE(node)) {
8609 case PM_ALIAS_GLOBAL_VARIABLE_NODE:
8610 // alias $foo $bar
8611 // ^^^^^^^^^^^^^^^
8612 pm_compile_alias_global_variable_node(iseq, (const pm_alias_global_variable_node_t *) node, &location, ret, popped, scope_node);
8613 return;
8614 case PM_ALIAS_METHOD_NODE:
8615 // alias foo bar
8616 // ^^^^^^^^^^^^^
8617 pm_compile_alias_method_node(iseq, (const pm_alias_method_node_t *) node, &location, ret, popped, scope_node);
8618 return;
8619 case PM_AND_NODE:
8620 // a and b
8621 // ^^^^^^^
8622 pm_compile_and_node(iseq, (const pm_and_node_t *) node, &location, ret, popped, scope_node);
8623 return;
8624 case PM_ARGUMENTS_NODE: {
8625 // break foo
8626 // ^^^
8627 //
8628 // These are ArgumentsNodes that are not compiled directly by their
8629 // parent call nodes, used in the cases of NextNodes, ReturnNodes, and
8630 // BreakNodes. They can create an array like ArrayNode.
8631 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
8632 const pm_node_list_t *elements = &cast->arguments;
8633
8634 if (elements->size == 1) {
8635 // If we are only returning a single element through one of the jump
8636 // nodes, then we will only compile that node directly.
8637 PM_COMPILE(elements->nodes[0]);
8638 }
8639 else {
8640 pm_compile_array_node(iseq, (const pm_node_t *) cast, elements, &location, ret, popped, scope_node);
8641 }
8642 return;
8643 }
8644 case PM_ARRAY_NODE: {
8645 // [foo, bar, baz]
8646 // ^^^^^^^^^^^^^^^
8647 const pm_array_node_t *cast = (const pm_array_node_t *) node;
8648 pm_compile_array_node(iseq, (const pm_node_t *) cast, &cast->elements, &location, ret, popped, scope_node);
8649 return;
8650 }
8651 case PM_ASSOC_NODE: {
8652 // { foo: 1 }
8653 // ^^^^^^
8654 //
8655 // foo(bar: 1)
8656 // ^^^^^^
8657 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
8658
8659 PM_COMPILE(cast->key);
8660 PM_COMPILE(cast->value);
8661
8662 return;
8663 }
8664 case PM_ASSOC_SPLAT_NODE: {
8665 // { **foo }
8666 // ^^^^^
8667 //
8668 // def foo(**); bar(**); end
8669 // ^^
8670 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
8671
8672 if (cast->value != NULL) {
8673 PM_COMPILE(cast->value);
8674 }
8675 else if (!popped) {
8676 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
8677 PUSH_GETLOCAL(ret, location, index.index, index.level);
8678 }
8679
8680 return;
8681 }
8682 case PM_BACK_REFERENCE_READ_NODE: {
8683 // $+
8684 // ^^
8685 if (!popped) {
8686 const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
8687 VALUE backref = pm_compile_back_reference_ref(cast);
8688
8689 PUSH_INSN2(ret, location, getspecial, INT2FIX(1), backref);
8690 }
8691 return;
8692 }
8693 case PM_BEGIN_NODE: {
8694 // begin end
8695 // ^^^^^^^^^
8696 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
8697
8698 if (cast->ensure_clause) {
8699 // Compiling the ensure clause will compile the rescue clause (if
8700 // there is one), which will compile the begin statements.
8701 pm_compile_ensure(iseq, cast, &location, ret, popped, scope_node);
8702 }
8703 else if (cast->rescue_clause) {
8704 // Compiling rescue will compile begin statements (if applicable).
8705 pm_compile_rescue(iseq, cast, &location, ret, popped, scope_node);
8706 }
8707 else {
8708 // If there is neither ensure or rescue, the just compile the
8709 // statements.
8710 if (cast->statements != NULL) {
8711 PM_COMPILE((const pm_node_t *) cast->statements);
8712 }
8713 else if (!popped) {
8714 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
8715 }
8716 }
8717 return;
8718 }
8719 case PM_BLOCK_ARGUMENT_NODE: {
8720 // foo(&bar)
8721 // ^^^^
8722 const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
8723
8724 if (cast->expression != NULL) {
8725 PM_COMPILE(cast->expression);
8726 }
8727 else {
8728 // If there's no expression, this must be block forwarding.
8729 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
8730 PUSH_INSN2(ret, location, getblockparamproxy, INT2FIX(local_index.index + VM_ENV_DATA_SIZE - 1), INT2FIX(local_index.level));
8731 }
8732 return;
8733 }
8734 case PM_BREAK_NODE:
8735 // break
8736 // ^^^^^
8737 //
8738 // break foo
8739 // ^^^^^^^^^
8740 pm_compile_break_node(iseq, (const pm_break_node_t *) node, &location, ret, popped, scope_node);
8741 return;
8742 case PM_CALL_NODE:
8743 // foo
8744 // ^^^
8745 //
8746 // foo.bar
8747 // ^^^^^^^
8748 //
8749 // foo.bar() {}
8750 // ^^^^^^^^^^^^
8751 pm_compile_call_node(iseq, (const pm_call_node_t *) node, ret, popped, scope_node);
8752 return;
8753 case PM_CALL_AND_WRITE_NODE: {
8754 // foo.bar &&= baz
8755 // ^^^^^^^^^^^^^^^
8756 const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
8757 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);
8758 return;
8759 }
8760 case PM_CALL_OR_WRITE_NODE: {
8761 // foo.bar ||= baz
8762 // ^^^^^^^^^^^^^^^
8763 const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
8764 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);
8765 return;
8766 }
8767 case PM_CALL_OPERATOR_WRITE_NODE:
8768 // foo.bar += baz
8769 // ^^^^^^^^^^^^^^^
8770 //
8771 // Call operator writes occur when you have a call node on the left-hand
8772 // side of a write operator that is not `=`. As an example,
8773 // `foo.bar *= 1`. This breaks down to caching the receiver on the
8774 // stack and then performing three method calls, one to read the value,
8775 // one to compute the result, and one to write the result back to the
8776 // receiver.
8777 pm_compile_call_operator_write_node(iseq, (const pm_call_operator_write_node_t *) node, &location, ret, popped, scope_node);
8778 return;
8779 case PM_CASE_NODE:
8780 // case foo; when bar; end
8781 // ^^^^^^^^^^^^^^^^^^^^^^^
8782 pm_compile_case_node(iseq, (const pm_case_node_t *) node, &location, ret, popped, scope_node);
8783 return;
8784 case PM_CASE_MATCH_NODE:
8785 // case foo; in bar; end
8786 // ^^^^^^^^^^^^^^^^^^^^^
8787 //
8788 // If you use the `case` keyword to create a case match node, it will
8789 // match against all of the `in` clauses until it finds one that
8790 // matches. If it doesn't find one, it can optionally fall back to an
8791 // `else` clause. If none is present and a match wasn't found, it will
8792 // raise an appropriate error.
8793 pm_compile_case_match_node(iseq, (const pm_case_match_node_t *) node, &location, ret, popped, scope_node);
8794 return;
8795 case PM_CLASS_NODE: {
8796 // class Foo; end
8797 // ^^^^^^^^^^^^^^
8798 const pm_class_node_t *cast = (const pm_class_node_t *) node;
8799
8800 ID class_id = pm_constant_id_lookup(scope_node, cast->name);
8801 VALUE class_name = rb_str_freeze(rb_sprintf("<class:%"PRIsVALUE">", rb_id2str(class_id)));
8802
8803 pm_scope_node_t next_scope_node;
8804 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
8805
8806 const rb_iseq_t *class_iseq = NEW_CHILD_ISEQ(&next_scope_node, class_name, ISEQ_TYPE_CLASS, location.line);
8807 pm_scope_node_destroy(&next_scope_node);
8808
8809 // TODO: Once we merge constant path nodes correctly, fix this flag
8810 const int flags = VM_DEFINECLASS_TYPE_CLASS |
8811 (cast->superclass ? VM_DEFINECLASS_FLAG_HAS_SUPERCLASS : 0) |
8812 pm_compile_class_path(iseq, cast->constant_path, &location, ret, false, scope_node);
8813
8814 if (cast->superclass) {
8815 PM_COMPILE_NOT_POPPED(cast->superclass);
8816 }
8817 else {
8818 PUSH_INSN(ret, location, putnil);
8819 }
8820
8821 {
8822 VALUE operand = ID2SYM(class_id);
8823 PUSH_INSN3(ret, location, defineclass, operand, class_iseq, INT2FIX(flags));
8824 }
8825 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)class_iseq);
8826
8827 if (popped) PUSH_INSN(ret, location, pop);
8828 return;
8829 }
8830 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
8831 // @@foo &&= bar
8832 // ^^^^^^^^^^^^^
8833 const pm_class_variable_and_write_node_t *cast = (const pm_class_variable_and_write_node_t *) node;
8834 LABEL *end_label = NEW_LABEL(location.line);
8835
8836 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8837 VALUE name = ID2SYM(name_id);
8838
8839 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8840 if (!popped) PUSH_INSN(ret, location, dup);
8841
8842 PUSH_INSNL(ret, location, branchunless, end_label);
8843 if (!popped) PUSH_INSN(ret, location, pop);
8844
8845 PM_COMPILE_NOT_POPPED(cast->value);
8846 if (!popped) PUSH_INSN(ret, location, dup);
8847
8848 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8849 PUSH_LABEL(ret, end_label);
8850
8851 return;
8852 }
8853 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
8854 // @@foo += bar
8855 // ^^^^^^^^^^^^
8856 const pm_class_variable_operator_write_node_t *cast = (const pm_class_variable_operator_write_node_t *) node;
8857
8858 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8859 VALUE name = ID2SYM(name_id);
8860
8861 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8862 PM_COMPILE_NOT_POPPED(cast->value);
8863
8864 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
8865 int flags = VM_CALL_ARGS_SIMPLE;
8866 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
8867
8868 if (!popped) PUSH_INSN(ret, location, dup);
8869 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8870
8871 return;
8872 }
8873 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
8874 // @@foo ||= bar
8875 // ^^^^^^^^^^^^^
8876 const pm_class_variable_or_write_node_t *cast = (const pm_class_variable_or_write_node_t *) node;
8877 LABEL *end_label = NEW_LABEL(location.line);
8878 LABEL *start_label = NEW_LABEL(location.line);
8879
8880 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
8881 VALUE name = ID2SYM(name_id);
8882
8883 PUSH_INSN(ret, location, putnil);
8884 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_CVAR), name, Qtrue);
8885 PUSH_INSNL(ret, location, branchunless, start_label);
8886
8887 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8888 if (!popped) PUSH_INSN(ret, location, dup);
8889
8890 PUSH_INSNL(ret, location, branchif, end_label);
8891 if (!popped) PUSH_INSN(ret, location, pop);
8892
8893 PUSH_LABEL(ret, start_label);
8894 PM_COMPILE_NOT_POPPED(cast->value);
8895 if (!popped) PUSH_INSN(ret, location, dup);
8896
8897 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8898 PUSH_LABEL(ret, end_label);
8899
8900 return;
8901 }
8902 case PM_CLASS_VARIABLE_READ_NODE: {
8903 // @@foo
8904 // ^^^^^
8905 if (!popped) {
8906 const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
8907 ID name = pm_constant_id_lookup(scope_node, cast->name);
8908 PUSH_INSN2(ret, location, getclassvariable, ID2SYM(name), get_cvar_ic_value(iseq, name));
8909 }
8910 return;
8911 }
8912 case PM_CLASS_VARIABLE_WRITE_NODE: {
8913 // @@foo = 1
8914 // ^^^^^^^^^
8915 const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
8916 PM_COMPILE_NOT_POPPED(cast->value);
8917 if (!popped) PUSH_INSN(ret, location, dup);
8918
8919 ID name = pm_constant_id_lookup(scope_node, cast->name);
8920 PUSH_INSN2(ret, location, setclassvariable, ID2SYM(name), get_cvar_ic_value(iseq, name));
8921
8922 return;
8923 }
8924 case PM_CONSTANT_PATH_NODE: {
8925 // Foo::Bar
8926 // ^^^^^^^^
8927 VALUE parts;
8928
8929 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache && ((parts = pm_constant_path_parts(node, scope_node)) != Qnil)) {
8930 ISEQ_BODY(iseq)->ic_size++;
8931 PUSH_INSN1(ret, location, opt_getconstant_path, parts);
8932 }
8933 else {
8934 DECL_ANCHOR(prefix);
8935 DECL_ANCHOR(body);
8936
8937 pm_compile_constant_path(iseq, node, prefix, body, popped, scope_node);
8938 if (LIST_INSN_SIZE_ZERO(prefix)) {
8939 PUSH_INSN(ret, location, putnil);
8940 }
8941 else {
8942 PUSH_SEQ(ret, prefix);
8943 }
8944
8945 PUSH_SEQ(ret, body);
8946 }
8947
8948 if (popped) PUSH_INSN(ret, location, pop);
8949 return;
8950 }
8951 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
8952 // Foo::Bar &&= baz
8953 // ^^^^^^^^^^^^^^^^
8954 const pm_constant_path_and_write_node_t *cast = (const pm_constant_path_and_write_node_t *) node;
8955 pm_compile_constant_path_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8956 return;
8957 }
8958 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
8959 // Foo::Bar ||= baz
8960 // ^^^^^^^^^^^^^^^^
8961 const pm_constant_path_or_write_node_t *cast = (const pm_constant_path_or_write_node_t *) node;
8962 pm_compile_constant_path_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8963 return;
8964 }
8965 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
8966 // Foo::Bar += baz
8967 // ^^^^^^^^^^^^^^^
8968 const pm_constant_path_operator_write_node_t *cast = (const pm_constant_path_operator_write_node_t *) node;
8969 pm_compile_constant_path_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8970 return;
8971 }
8972 case PM_CONSTANT_PATH_WRITE_NODE: {
8973 // Foo::Bar = 1
8974 // ^^^^^^^^^^^^
8975 const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
8976 pm_compile_constant_path_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8977 return;
8978 }
8979 case PM_CONSTANT_READ_NODE: {
8980 // Foo
8981 // ^^^
8982 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
8983 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
8984
8985 pm_compile_constant_read(iseq, name, &cast->base.location, location.node_id, ret, scope_node);
8986 if (popped) PUSH_INSN(ret, location, pop);
8987
8988 return;
8989 }
8990 case PM_CONSTANT_AND_WRITE_NODE: {
8991 // Foo &&= bar
8992 // ^^^^^^^^^^^
8993 const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
8994 pm_compile_constant_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8995 return;
8996 }
8997 case PM_CONSTANT_OR_WRITE_NODE: {
8998 // Foo ||= bar
8999 // ^^^^^^^^^^^
9000 const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
9001 pm_compile_constant_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9002 return;
9003 }
9004 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
9005 // Foo += bar
9006 // ^^^^^^^^^^
9007 const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
9008 pm_compile_constant_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9009 return;
9010 }
9011 case PM_CONSTANT_WRITE_NODE: {
9012 // Foo = 1
9013 // ^^^^^^^
9014 const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
9015 pm_compile_constant_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9016 return;
9017 }
9018 case PM_DEF_NODE: {
9019 // def foo; end
9020 // ^^^^^^^^^^^^
9021 //
9022 // def self.foo; end
9023 // ^^^^^^^^^^^^^^^^^
9024 const pm_def_node_t *cast = (const pm_def_node_t *) node;
9025 ID method_name = pm_constant_id_lookup(scope_node, cast->name);
9026
9027 pm_scope_node_t next_scope_node;
9028 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9029
9030 rb_iseq_t *method_iseq = NEW_ISEQ(&next_scope_node, rb_id2str(method_name), ISEQ_TYPE_METHOD, location.line);
9031 pm_scope_node_destroy(&next_scope_node);
9032
9033 if (cast->receiver) {
9034 PM_COMPILE_NOT_POPPED(cast->receiver);
9035 PUSH_INSN2(ret, location, definesmethod, ID2SYM(method_name), method_iseq);
9036 }
9037 else {
9038 PUSH_INSN2(ret, location, definemethod, ID2SYM(method_name), method_iseq);
9039 }
9040 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) method_iseq);
9041
9042 if (!popped) {
9043 PUSH_INSN1(ret, location, putobject, ID2SYM(method_name));
9044 }
9045
9046 return;
9047 }
9048 case PM_DEFINED_NODE: {
9049 // defined?(a)
9050 // ^^^^^^^^^^^
9051 const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
9052 pm_compile_defined_expr(iseq, cast->value, &location, ret, popped, scope_node, false);
9053 return;
9054 }
9055 case PM_EMBEDDED_STATEMENTS_NODE: {
9056 // "foo #{bar}"
9057 // ^^^^^^
9058 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
9059
9060 if (cast->statements != NULL) {
9061 PM_COMPILE((const pm_node_t *) (cast->statements));
9062 }
9063 else {
9064 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9065 }
9066
9067 if (popped) PUSH_INSN(ret, location, pop);
9068 return;
9069 }
9070 case PM_EMBEDDED_VARIABLE_NODE: {
9071 // "foo #@bar"
9072 // ^^^^^
9073 const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
9074 PM_COMPILE(cast->variable);
9075 return;
9076 }
9077 case PM_FALSE_NODE: {
9078 // false
9079 // ^^^^^
9080 if (!popped) {
9081 PUSH_INSN1(ret, location, putobject, Qfalse);
9082 }
9083 return;
9084 }
9085 case PM_ENSURE_NODE: {
9086 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
9087
9088 if (cast->statements != NULL) {
9089 PM_COMPILE((const pm_node_t *) cast->statements);
9090 }
9091
9092 return;
9093 }
9094 case PM_ELSE_NODE: {
9095 // if foo then bar else baz end
9096 // ^^^^^^^^^^^^
9097 const pm_else_node_t *cast = (const pm_else_node_t *) node;
9098
9099 if (cast->statements != NULL) {
9100 PM_COMPILE((const pm_node_t *) cast->statements);
9101 }
9102 else if (!popped) {
9103 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9104 }
9105
9106 return;
9107 }
9108 case PM_FLIP_FLOP_NODE: {
9109 // if foo .. bar; end
9110 // ^^^^^^^^^^
9111 const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
9112
9113 LABEL *final_label = NEW_LABEL(location.line);
9114 LABEL *then_label = NEW_LABEL(location.line);
9115 LABEL *else_label = NEW_LABEL(location.line);
9116
9117 pm_compile_flip_flop(cast, else_label, then_label, iseq, location.line, ret, popped, scope_node);
9118
9119 PUSH_LABEL(ret, then_label);
9120 PUSH_INSN1(ret, location, putobject, Qtrue);
9121 PUSH_INSNL(ret, location, jump, final_label);
9122 PUSH_LABEL(ret, else_label);
9123 PUSH_INSN1(ret, location, putobject, Qfalse);
9124 PUSH_LABEL(ret, final_label);
9125
9126 return;
9127 }
9128 case PM_FLOAT_NODE: {
9129 // 1.0
9130 // ^^^
9131 if (!popped) {
9132 VALUE operand = parse_float((const pm_float_node_t *) node);
9133 PUSH_INSN1(ret, location, putobject, operand);
9134 }
9135 return;
9136 }
9137 case PM_FOR_NODE: {
9138 // for foo in bar do end
9139 // ^^^^^^^^^^^^^^^^^^^^^
9140 const pm_for_node_t *cast = (const pm_for_node_t *) node;
9141
9142 LABEL *retry_label = NEW_LABEL(location.line);
9143 LABEL *retry_end_l = NEW_LABEL(location.line);
9144
9145 // First, compile the collection that we're going to be iterating over.
9146 PUSH_LABEL(ret, retry_label);
9147 PM_COMPILE_NOT_POPPED(cast->collection);
9148
9149 // Next, create the new scope that is going to contain the block that
9150 // will be passed to the each method.
9151 pm_scope_node_t next_scope_node;
9152 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9153
9154 const rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location.line);
9155 pm_scope_node_destroy(&next_scope_node);
9156
9157 const rb_iseq_t *prev_block = ISEQ_COMPILE_DATA(iseq)->current_block;
9158 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
9159
9160 // Now, create the method call to each that will be used to iterate over
9161 // the collection, and pass the newly created iseq as the block.
9162 PUSH_SEND_WITH_BLOCK(ret, location, idEach, INT2FIX(0), child_iseq);
9163 pm_compile_retry_end_label(iseq, ret, retry_end_l);
9164
9165 if (popped) PUSH_INSN(ret, location, pop);
9166 ISEQ_COMPILE_DATA(iseq)->current_block = prev_block;
9167 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, child_iseq, retry_end_l);
9168 return;
9169 }
9170 case PM_FORWARDING_ARGUMENTS_NODE:
9171 rb_bug("Cannot compile a ForwardingArgumentsNode directly\n");
9172 return;
9173 case PM_FORWARDING_SUPER_NODE:
9174 // super
9175 // ^^^^^
9176 //
9177 // super {}
9178 // ^^^^^^^^
9179 pm_compile_forwarding_super_node(iseq, (const pm_forwarding_super_node_t *) node, &location, ret, popped, scope_node);
9180 return;
9181 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
9182 // $foo &&= bar
9183 // ^^^^^^^^^^^^
9184 const pm_global_variable_and_write_node_t *cast = (const pm_global_variable_and_write_node_t *) node;
9185 LABEL *end_label = NEW_LABEL(location.line);
9186
9187 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9188 PUSH_INSN1(ret, location, getglobal, name);
9189 if (!popped) PUSH_INSN(ret, location, dup);
9190
9191 PUSH_INSNL(ret, location, branchunless, end_label);
9192 if (!popped) PUSH_INSN(ret, location, pop);
9193
9194 PM_COMPILE_NOT_POPPED(cast->value);
9195 if (!popped) PUSH_INSN(ret, location, dup);
9196
9197 PUSH_INSN1(ret, location, setglobal, name);
9198 PUSH_LABEL(ret, end_label);
9199
9200 return;
9201 }
9202 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
9203 // $foo += bar
9204 // ^^^^^^^^^^^
9205 const pm_global_variable_operator_write_node_t *cast = (const pm_global_variable_operator_write_node_t *) node;
9206
9207 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9208 PUSH_INSN1(ret, location, getglobal, name);
9209 PM_COMPILE_NOT_POPPED(cast->value);
9210
9211 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9212 int flags = VM_CALL_ARGS_SIMPLE;
9213 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
9214
9215 if (!popped) PUSH_INSN(ret, location, dup);
9216 PUSH_INSN1(ret, location, setglobal, name);
9217
9218 return;
9219 }
9220 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
9221 // $foo ||= bar
9222 // ^^^^^^^^^^^^
9223 const pm_global_variable_or_write_node_t *cast = (const pm_global_variable_or_write_node_t *) node;
9224 LABEL *set_label = NEW_LABEL(location.line);
9225 LABEL *end_label = NEW_LABEL(location.line);
9226
9227 PUSH_INSN(ret, location, putnil);
9228 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9229
9230 PUSH_INSN3(ret, location, defined, INT2FIX(DEFINED_GVAR), name, Qtrue);
9231 PUSH_INSNL(ret, location, branchunless, set_label);
9232
9233 PUSH_INSN1(ret, location, getglobal, name);
9234 if (!popped) PUSH_INSN(ret, location, dup);
9235
9236 PUSH_INSNL(ret, location, branchif, end_label);
9237 if (!popped) PUSH_INSN(ret, location, pop);
9238
9239 PUSH_LABEL(ret, set_label);
9240 PM_COMPILE_NOT_POPPED(cast->value);
9241 if (!popped) PUSH_INSN(ret, location, dup);
9242
9243 PUSH_INSN1(ret, location, setglobal, name);
9244 PUSH_LABEL(ret, end_label);
9245
9246 return;
9247 }
9248 case PM_GLOBAL_VARIABLE_READ_NODE: {
9249 // $foo
9250 // ^^^^
9251 const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
9252 VALUE name = ID2SYM(pm_constant_id_lookup(scope_node, cast->name));
9253
9254 PUSH_INSN1(ret, location, getglobal, name);
9255 if (popped) PUSH_INSN(ret, location, pop);
9256
9257 return;
9258 }
9259 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
9260 // $foo = 1
9261 // ^^^^^^^^
9262 const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
9263 PM_COMPILE_NOT_POPPED(cast->value);
9264 if (!popped) PUSH_INSN(ret, location, dup);
9265
9266 ID name = pm_constant_id_lookup(scope_node, cast->name);
9267 PUSH_INSN1(ret, location, setglobal, ID2SYM(name));
9268
9269 return;
9270 }
9271 case PM_HASH_NODE: {
9272 // {}
9273 // ^^
9274 //
9275 // If every node in the hash is static, then we can compile the entire
9276 // hash now instead of later.
9277 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9278 // We're only going to compile this node if it's not popped. If it
9279 // is popped, then we know we don't need to do anything since it's
9280 // statically known.
9281 if (!popped) {
9282 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
9283
9284 if (cast->elements.size == 0) {
9285 PUSH_INSN1(ret, location, newhash, INT2FIX(0));
9286 }
9287 else {
9288 VALUE value = pm_static_literal_value(iseq, node, scope_node);
9289 PUSH_INSN1(ret, location, duphash, value);
9290 RB_OBJ_WRITTEN(iseq, Qundef, value);
9291 }
9292 }
9293 }
9294 else {
9295 // Here since we know there are possible side-effects inside the
9296 // hash contents, we're going to build it entirely at runtime. We'll
9297 // do this by pushing all of the key-value pairs onto the stack and
9298 // then combining them with newhash.
9299 //
9300 // If this hash is popped, then this serves only to ensure we enact
9301 // all side-effects (like method calls) that are contained within
9302 // the hash contents.
9303 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
9304 const pm_node_list_t *elements = &cast->elements;
9305
9306 if (popped) {
9307 // If this hash is popped, then we can iterate through each
9308 // element and compile it. The result of each compilation will
9309 // only include the side effects of the element itself.
9310 for (size_t index = 0; index < elements->size; index++) {
9311 PM_COMPILE_POPPED(elements->nodes[index]);
9312 }
9313 }
9314 else {
9315 pm_compile_hash_elements(iseq, node, elements, 0, Qundef, false, ret, scope_node);
9316 }
9317 }
9318
9319 return;
9320 }
9321 case PM_IF_NODE: {
9322 // if foo then bar end
9323 // ^^^^^^^^^^^^^^^^^^^
9324 //
9325 // bar if foo
9326 // ^^^^^^^^^^
9327 //
9328 // foo ? bar : baz
9329 // ^^^^^^^^^^^^^^^
9330 const pm_if_node_t *cast = (const pm_if_node_t *) node;
9331 pm_compile_conditional(iseq, &location, PM_IF_NODE, (const pm_node_t *) cast, cast->statements, cast->subsequent, cast->predicate, ret, popped, scope_node);
9332 return;
9333 }
9334 case PM_IMAGINARY_NODE: {
9335 // 1i
9336 // ^^
9337 if (!popped) {
9338 VALUE operand = parse_imaginary((const pm_imaginary_node_t *) node);
9339 PUSH_INSN1(ret, location, putobject, operand);
9340 }
9341 return;
9342 }
9343 case PM_IMPLICIT_NODE: {
9344 // Implicit nodes mark places in the syntax tree where explicit syntax
9345 // was omitted, but implied. For example,
9346 //
9347 // { foo: }
9348 //
9349 // In this case a method call/local variable read is implied by virtue
9350 // of the missing value. To compile these nodes, we simply compile the
9351 // value that is implied, which is helpfully supplied by the parser.
9352 const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
9353 PM_COMPILE(cast->value);
9354 return;
9355 }
9356 case PM_IN_NODE: {
9357 // In nodes are handled by the case match node directly, so we should
9358 // never end up hitting them through this path.
9359 rb_bug("Should not ever enter an in node directly");
9360 return;
9361 }
9362 case PM_INDEX_OPERATOR_WRITE_NODE: {
9363 // foo[bar] += baz
9364 // ^^^^^^^^^^^^^^^
9365 const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
9366 pm_compile_index_operator_write_node(iseq, cast, &location, ret, popped, scope_node);
9367 return;
9368 }
9369 case PM_INDEX_AND_WRITE_NODE: {
9370 // foo[bar] &&= baz
9371 // ^^^^^^^^^^^^^^^^
9372 const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
9373 pm_compile_index_control_flow_write_node(iseq, node, cast->receiver, cast->arguments, cast->block, cast->value, &location, ret, popped, scope_node);
9374 return;
9375 }
9376 case PM_INDEX_OR_WRITE_NODE: {
9377 // foo[bar] ||= baz
9378 // ^^^^^^^^^^^^^^^^
9379 const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
9380 pm_compile_index_control_flow_write_node(iseq, node, cast->receiver, cast->arguments, cast->block, cast->value, &location, ret, popped, scope_node);
9381 return;
9382 }
9383 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
9384 // @foo &&= bar
9385 // ^^^^^^^^^^^^
9386 const pm_instance_variable_and_write_node_t *cast = (const pm_instance_variable_and_write_node_t *) node;
9387 LABEL *end_label = NEW_LABEL(location.line);
9388
9389 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9390 VALUE name = ID2SYM(name_id);
9391
9392 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9393 if (!popped) PUSH_INSN(ret, location, dup);
9394
9395 PUSH_INSNL(ret, location, branchunless, end_label);
9396 if (!popped) PUSH_INSN(ret, location, pop);
9397
9398 PM_COMPILE_NOT_POPPED(cast->value);
9399 if (!popped) PUSH_INSN(ret, location, dup);
9400
9401 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9402 PUSH_LABEL(ret, end_label);
9403
9404 return;
9405 }
9406 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
9407 // @foo += bar
9408 // ^^^^^^^^^^^
9409 const pm_instance_variable_operator_write_node_t *cast = (const pm_instance_variable_operator_write_node_t *) node;
9410
9411 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9412 VALUE name = ID2SYM(name_id);
9413
9414 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9415 PM_COMPILE_NOT_POPPED(cast->value);
9416
9417 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9418 int flags = VM_CALL_ARGS_SIMPLE;
9419 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(flags));
9420
9421 if (!popped) PUSH_INSN(ret, location, dup);
9422 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9423
9424 return;
9425 }
9426 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
9427 // @foo ||= bar
9428 // ^^^^^^^^^^^^
9429 const pm_instance_variable_or_write_node_t *cast = (const pm_instance_variable_or_write_node_t *) node;
9430 LABEL *end_label = NEW_LABEL(location.line);
9431
9432 ID name_id = pm_constant_id_lookup(scope_node, cast->name);
9433 VALUE name = ID2SYM(name_id);
9434
9435 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9436 if (!popped) PUSH_INSN(ret, location, dup);
9437
9438 PUSH_INSNL(ret, location, branchif, end_label);
9439 if (!popped) PUSH_INSN(ret, location, pop);
9440
9441 PM_COMPILE_NOT_POPPED(cast->value);
9442 if (!popped) PUSH_INSN(ret, location, dup);
9443
9444 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9445 PUSH_LABEL(ret, end_label);
9446
9447 return;
9448 }
9449 case PM_INSTANCE_VARIABLE_READ_NODE: {
9450 // @foo
9451 // ^^^^
9452 if (!popped) {
9453 const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
9454 ID name = pm_constant_id_lookup(scope_node, cast->name);
9455 PUSH_INSN2(ret, location, getinstancevariable, ID2SYM(name), get_ivar_ic_value(iseq, name));
9456 }
9457 return;
9458 }
9459 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
9460 // @foo = 1
9461 // ^^^^^^^^
9462 const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
9463 PM_COMPILE_NOT_POPPED(cast->value);
9464 if (!popped) PUSH_INSN(ret, location, dup);
9465
9466 ID name = pm_constant_id_lookup(scope_node, cast->name);
9467 PUSH_INSN2(ret, location, setinstancevariable, ID2SYM(name), get_ivar_ic_value(iseq, name));
9468
9469 return;
9470 }
9471 case PM_INTEGER_NODE: {
9472 // 1
9473 // ^
9474 if (!popped) {
9475 VALUE operand = parse_integer((const pm_integer_node_t *) node);
9476 PUSH_INSN1(ret, location, putobject, operand);
9477 }
9478 return;
9479 }
9480 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
9481 // if /foo #{bar}/ then end
9482 // ^^^^^^^^^^^^
9483 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9484 if (!popped) {
9485 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9486 PUSH_INSN1(ret, location, putobject, regexp);
9487 }
9488 }
9489 else {
9490 pm_compile_regexp_dynamic(iseq, node, &((const pm_interpolated_match_last_line_node_t *) node)->parts, &location, ret, popped, scope_node);
9491 }
9492
9493 PUSH_INSN1(ret, location, getglobal, rb_id2sym(idLASTLINE));
9494 PUSH_SEND(ret, location, idEqTilde, INT2NUM(1));
9495 if (popped) PUSH_INSN(ret, location, pop);
9496
9497 return;
9498 }
9499 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
9500 // /foo #{bar}/
9501 // ^^^^^^^^^^^^
9502 if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
9503 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
9504 const rb_iseq_t *block_iseq = NULL;
9505 int ise_index = ISEQ_BODY(iseq)->ise_size++;
9506
9507 pm_scope_node_t next_scope_node;
9508 pm_scope_node_init(node, &next_scope_node, scope_node);
9509
9510 block_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_PLAIN, location.line);
9511 pm_scope_node_destroy(&next_scope_node);
9512
9513 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
9514 PUSH_INSN2(ret, location, once, block_iseq, INT2FIX(ise_index));
9515 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
9516
9517 if (popped) PUSH_INSN(ret, location, pop);
9518 return;
9519 }
9520
9521 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9522 if (!popped) {
9523 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9524 PUSH_INSN1(ret, location, putobject, regexp);
9525 }
9526 }
9527 else {
9528 pm_compile_regexp_dynamic(iseq, node, &((const pm_interpolated_regular_expression_node_t *) node)->parts, &location, ret, popped, scope_node);
9529 if (popped) PUSH_INSN(ret, location, pop);
9530 }
9531
9532 return;
9533 }
9534 case PM_INTERPOLATED_STRING_NODE: {
9535 // "foo #{bar}"
9536 // ^^^^^^^^^^^^
9537 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
9538 if (!popped) {
9539 VALUE string = pm_static_literal_value(iseq, node, scope_node);
9540
9541 if (PM_NODE_FLAG_P(node, PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN)) {
9542 PUSH_INSN1(ret, location, putobject, string);
9543 }
9544 else if (PM_NODE_FLAG_P(node, PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE)) {
9545 PUSH_INSN1(ret, location, putstring, string);
9546 }
9547 else {
9548 PUSH_INSN1(ret, location, putchilledstring, string);
9549 }
9550 }
9551 }
9552 else {
9553 const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
9554 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, popped, scope_node, NULL, NULL);
9555 if (length > 1) PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9556 if (popped) PUSH_INSN(ret, location, pop);
9557 }
9558
9559 return;
9560 }
9561 case PM_INTERPOLATED_SYMBOL_NODE: {
9562 // :"foo #{bar}"
9563 // ^^^^^^^^^^^^^
9564 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
9565 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, popped, scope_node, NULL, NULL);
9566
9567 if (length > 1) {
9568 PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9569 }
9570
9571 if (!popped) {
9572 PUSH_INSN(ret, location, intern);
9573 }
9574 else {
9575 PUSH_INSN(ret, location, pop);
9576 }
9577
9578 return;
9579 }
9580 case PM_INTERPOLATED_X_STRING_NODE: {
9581 // `foo #{bar}`
9582 // ^^^^^^^^^^^^
9583 const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
9584
9585 PUSH_INSN(ret, location, putself);
9586
9587 int length = pm_interpolated_node_compile(iseq, &cast->parts, &location, ret, false, scope_node, NULL, NULL);
9588 if (length > 1) PUSH_INSN1(ret, location, concatstrings, INT2FIX(length));
9589
9590 PUSH_SEND_WITH_FLAG(ret, location, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
9591 if (popped) PUSH_INSN(ret, location, pop);
9592
9593 return;
9594 }
9595 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
9596 // -> { it }
9597 // ^^
9598 if (!popped) {
9599 PUSH_GETLOCAL(ret, location, scope_node->local_table_for_iseq_size, 0);
9600 }
9601
9602 return;
9603 }
9604 case PM_KEYWORD_HASH_NODE: {
9605 // foo(bar: baz)
9606 // ^^^^^^^^
9607 const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
9608 const pm_node_list_t *elements = &cast->elements;
9609
9610 const pm_node_t *element;
9611 PM_NODE_LIST_FOREACH(elements, index, element) {
9612 PM_COMPILE(element);
9613 }
9614
9615 if (!popped) PUSH_INSN1(ret, location, newhash, INT2FIX(elements->size * 2));
9616 return;
9617 }
9618 case PM_LAMBDA_NODE: {
9619 // -> {}
9620 // ^^^^^
9621 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
9622
9623 pm_scope_node_t next_scope_node;
9624 pm_scope_node_init(node, &next_scope_node, scope_node);
9625
9626 int opening_lineno = pm_location_line_number(parser, &cast->opening_loc);
9627 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, opening_lineno);
9628 pm_scope_node_destroy(&next_scope_node);
9629
9630 VALUE argc = INT2FIX(0);
9631 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
9632 PUSH_CALL_WITH_BLOCK(ret, location, idLambda, argc, block);
9633 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) block);
9634
9635 if (popped) PUSH_INSN(ret, location, pop);
9636 return;
9637 }
9638 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
9639 // foo &&= bar
9640 // ^^^^^^^^^^^
9641 const pm_local_variable_and_write_node_t *cast = (const pm_local_variable_and_write_node_t *) node;
9642 LABEL *end_label = NEW_LABEL(location.line);
9643
9644 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9645 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9646 if (!popped) PUSH_INSN(ret, location, dup);
9647
9648 PUSH_INSNL(ret, location, branchunless, end_label);
9649 if (!popped) PUSH_INSN(ret, location, pop);
9650
9651 PM_COMPILE_NOT_POPPED(cast->value);
9652 if (!popped) PUSH_INSN(ret, location, dup);
9653
9654 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9655 PUSH_LABEL(ret, end_label);
9656
9657 return;
9658 }
9659 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
9660 // foo += bar
9661 // ^^^^^^^^^^
9662 const pm_local_variable_operator_write_node_t *cast = (const pm_local_variable_operator_write_node_t *) node;
9663
9664 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9665 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9666
9667 PM_COMPILE_NOT_POPPED(cast->value);
9668
9669 ID method_id = pm_constant_id_lookup(scope_node, cast->binary_operator);
9670 PUSH_SEND_WITH_FLAG(ret, location, method_id, INT2NUM(1), INT2FIX(VM_CALL_ARGS_SIMPLE));
9671
9672 if (!popped) PUSH_INSN(ret, location, dup);
9673 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9674
9675 return;
9676 }
9677 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
9678 // foo ||= bar
9679 // ^^^^^^^^^^^
9680 const pm_local_variable_or_write_node_t *cast = (const pm_local_variable_or_write_node_t *) node;
9681
9682 LABEL *set_label = NEW_LABEL(location.line);
9683 LABEL *end_label = NEW_LABEL(location.line);
9684
9685 PUSH_INSN1(ret, location, putobject, Qtrue);
9686 PUSH_INSNL(ret, location, branchunless, set_label);
9687
9688 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9689 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9690 if (!popped) PUSH_INSN(ret, location, dup);
9691
9692 PUSH_INSNL(ret, location, branchif, end_label);
9693 if (!popped) PUSH_INSN(ret, location, pop);
9694
9695 PUSH_LABEL(ret, set_label);
9696 PM_COMPILE_NOT_POPPED(cast->value);
9697 if (!popped) PUSH_INSN(ret, location, dup);
9698
9699 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9700 PUSH_LABEL(ret, end_label);
9701
9702 return;
9703 }
9704 case PM_LOCAL_VARIABLE_READ_NODE: {
9705 // foo
9706 // ^^^
9707 if (!popped) {
9708 const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) node;
9709 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9710 PUSH_GETLOCAL(ret, location, index.index, index.level);
9711 }
9712
9713 return;
9714 }
9715 case PM_LOCAL_VARIABLE_WRITE_NODE: {
9716 // foo = 1
9717 // ^^^^^^^
9718 const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
9719 PM_COMPILE_NOT_POPPED(cast->value);
9720 if (!popped) PUSH_INSN(ret, location, dup);
9721
9722 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, cast->depth);
9723 PUSH_SETLOCAL(ret, location, index.index, index.level);
9724 return;
9725 }
9726 case PM_MATCH_LAST_LINE_NODE: {
9727 // if /foo/ then end
9728 // ^^^^^
9729 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9730
9731 PUSH_INSN1(ret, location, putobject, regexp);
9732 PUSH_INSN2(ret, location, getspecial, INT2FIX(0), INT2FIX(0));
9733 PUSH_SEND(ret, location, idEqTilde, INT2NUM(1));
9734 if (popped) PUSH_INSN(ret, location, pop);
9735
9736 return;
9737 }
9738 case PM_MATCH_PREDICATE_NODE: {
9739 // foo in bar
9740 // ^^^^^^^^^^
9741 const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
9742
9743 // First, allocate some stack space for the cached return value of any
9744 // calls to #deconstruct.
9745 PUSH_INSN(ret, location, putnil);
9746
9747 // Next, compile the expression that we're going to match against.
9748 PM_COMPILE_NOT_POPPED(cast->value);
9749 PUSH_INSN(ret, location, dup);
9750
9751 // Now compile the pattern that is going to be used to match against the
9752 // expression.
9753 LABEL *matched_label = NEW_LABEL(location.line);
9754 LABEL *unmatched_label = NEW_LABEL(location.line);
9755 LABEL *done_label = NEW_LABEL(location.line);
9756 pm_compile_pattern(iseq, scope_node, cast->pattern, ret, matched_label, unmatched_label, false, false, true, 2);
9757
9758 // If the pattern did not match, then compile the necessary instructions
9759 // to handle pushing false onto the stack, then jump to the end.
9760 PUSH_LABEL(ret, unmatched_label);
9761 PUSH_INSN(ret, location, pop);
9762 PUSH_INSN(ret, location, pop);
9763
9764 if (!popped) PUSH_INSN1(ret, location, putobject, Qfalse);
9765 PUSH_INSNL(ret, location, jump, done_label);
9766 PUSH_INSN(ret, location, putnil);
9767
9768 // If the pattern did match, then compile the necessary instructions to
9769 // handle pushing true onto the stack, then jump to the end.
9770 PUSH_LABEL(ret, matched_label);
9771 PUSH_INSN1(ret, location, adjuststack, INT2FIX(2));
9772 if (!popped) PUSH_INSN1(ret, location, putobject, Qtrue);
9773 PUSH_INSNL(ret, location, jump, done_label);
9774
9775 PUSH_LABEL(ret, done_label);
9776 return;
9777 }
9778 case PM_MATCH_REQUIRED_NODE:
9779 // foo => bar
9780 // ^^^^^^^^^^
9781 //
9782 // A match required node represents pattern matching against a single
9783 // pattern using the => operator. For example,
9784 //
9785 // foo => bar
9786 //
9787 // This is somewhat analogous to compiling a case match statement with a
9788 // single pattern. In both cases, if the pattern fails it should
9789 // immediately raise an error.
9790 pm_compile_match_required_node(iseq, (const pm_match_required_node_t *) node, &location, ret, popped, scope_node);
9791 return;
9792 case PM_MATCH_WRITE_NODE:
9793 // /(?<foo>foo)/ =~ bar
9794 // ^^^^^^^^^^^^^^^^^^^^
9795 //
9796 // Match write nodes are specialized call nodes that have a regular
9797 // expression with valid named capture groups on the left, the =~
9798 // operator, and some value on the right. The nodes themselves simply
9799 // wrap the call with the local variable targets that will be written
9800 // when the call is executed.
9801 pm_compile_match_write_node(iseq, (const pm_match_write_node_t *) node, &location, ret, popped, scope_node);
9802 return;
9803 case PM_MISSING_NODE:
9804 rb_bug("A pm_missing_node_t should not exist in prism's AST.");
9805 return;
9806 case PM_MODULE_NODE: {
9807 // module Foo; end
9808 // ^^^^^^^^^^^^^^^
9809 const pm_module_node_t *cast = (const pm_module_node_t *) node;
9810
9811 ID module_id = pm_constant_id_lookup(scope_node, cast->name);
9812 VALUE module_name = rb_str_freeze(rb_sprintf("<module:%"PRIsVALUE">", rb_id2str(module_id)));
9813
9814 pm_scope_node_t next_scope_node;
9815 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
9816
9817 const rb_iseq_t *module_iseq = NEW_CHILD_ISEQ(&next_scope_node, module_name, ISEQ_TYPE_CLASS, location.line);
9818 pm_scope_node_destroy(&next_scope_node);
9819
9820 const int flags = VM_DEFINECLASS_TYPE_MODULE | pm_compile_class_path(iseq, cast->constant_path, &location, ret, false, scope_node);
9821 PUSH_INSN(ret, location, putnil);
9822 PUSH_INSN3(ret, location, defineclass, ID2SYM(module_id), module_iseq, INT2FIX(flags));
9823 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) module_iseq);
9824
9825 if (popped) PUSH_INSN(ret, location, pop);
9826 return;
9827 }
9828 case PM_REQUIRED_PARAMETER_NODE: {
9829 // def foo(bar); end
9830 // ^^^
9831 const pm_required_parameter_node_t *cast = (const pm_required_parameter_node_t *) node;
9832 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, 0);
9833
9834 PUSH_SETLOCAL(ret, location, index.index, index.level);
9835 return;
9836 }
9837 case PM_MULTI_WRITE_NODE: {
9838 // foo, bar = baz
9839 // ^^^^^^^^^^^^^^
9840 //
9841 // A multi write node represents writing to multiple values using an =
9842 // operator. Importantly these nodes are only parsed when the left-hand
9843 // side of the operator has multiple targets. The right-hand side of the
9844 // operator having multiple targets represents an implicit array
9845 // instead.
9846 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
9847
9848 DECL_ANCHOR(writes);
9849 DECL_ANCHOR(cleanup);
9850
9851 pm_multi_target_state_t state = { 0 };
9852 state.position = popped ? 0 : 1;
9853 pm_compile_multi_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
9854
9855 PM_COMPILE_NOT_POPPED(cast->value);
9856 if (!popped) PUSH_INSN(ret, location, dup);
9857
9858 PUSH_SEQ(ret, writes);
9859 if (!popped && state.stack_size >= 1) {
9860 // Make sure the value on the right-hand side of the = operator is
9861 // being returned before we pop the parent expressions.
9862 PUSH_INSN1(ret, location, setn, INT2FIX(state.stack_size));
9863 }
9864
9865 // Now, we need to go back and modify the topn instructions in order to
9866 // ensure they can correctly retrieve the parent expressions.
9867 pm_multi_target_state_update(&state);
9868
9869 PUSH_SEQ(ret, cleanup);
9870 return;
9871 }
9872 case PM_NEXT_NODE:
9873 // next
9874 // ^^^^
9875 //
9876 // next foo
9877 // ^^^^^^^^
9878 pm_compile_next_node(iseq, (const pm_next_node_t *) node, &location, ret, popped, scope_node);
9879 return;
9880 case PM_NIL_NODE: {
9881 // nil
9882 // ^^^
9883 if (!popped) {
9884 PUSH_INSN(ret, location, putnil);
9885 }
9886
9887 return;
9888 }
9889 case PM_NO_KEYWORDS_PARAMETER_NODE: {
9890 // def foo(**nil); end
9891 // ^^^^^
9892 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg = TRUE;
9893 return;
9894 }
9895 case PM_NUMBERED_REFERENCE_READ_NODE: {
9896 // $1
9897 // ^^
9898 if (!popped) {
9899 const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
9900
9901 if (cast->number != 0) {
9902 VALUE ref = pm_compile_numbered_reference_ref(cast);
9903 PUSH_INSN2(ret, location, getspecial, INT2FIX(1), ref);
9904 }
9905 else {
9906 PUSH_INSN(ret, location, putnil);
9907 }
9908 }
9909
9910 return;
9911 }
9912 case PM_OR_NODE: {
9913 // a or b
9914 // ^^^^^^
9915 const pm_or_node_t *cast = (const pm_or_node_t *) node;
9916
9917 LABEL *end_label = NEW_LABEL(location.line);
9918 PM_COMPILE_NOT_POPPED(cast->left);
9919
9920 if (!popped) PUSH_INSN(ret, location, dup);
9921 PUSH_INSNL(ret, location, branchif, end_label);
9922
9923 if (!popped) PUSH_INSN(ret, location, pop);
9924 PM_COMPILE(cast->right);
9925 PUSH_LABEL(ret, end_label);
9926
9927 return;
9928 }
9929 case PM_OPTIONAL_PARAMETER_NODE: {
9930 // def foo(bar = 1); end
9931 // ^^^^^^^
9932 const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
9933 PM_COMPILE_NOT_POPPED(cast->value);
9934
9935 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->name, 0);
9936 PUSH_SETLOCAL(ret, location, index.index, index.level);
9937
9938 return;
9939 }
9940 case PM_PARENTHESES_NODE: {
9941 // ()
9942 // ^^
9943 //
9944 // (1)
9945 // ^^^
9946 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
9947
9948 if (cast->body != NULL) {
9949 PM_COMPILE(cast->body);
9950 }
9951 else if (!popped) {
9952 PUSH_INSN(ret, location, putnil);
9953 }
9954
9955 return;
9956 }
9957 case PM_PRE_EXECUTION_NODE: {
9958 // BEGIN {}
9959 // ^^^^^^^^
9960 const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
9961
9962 LINK_ANCHOR *outer_pre = scope_node->pre_execution_anchor;
9963 RUBY_ASSERT(outer_pre != NULL);
9964
9965 // BEGIN{} nodes can be nested, so here we're going to do the same thing
9966 // that we did for the top-level compilation where we create two
9967 // anchors and then join them in the correct order into the resulting
9968 // anchor.
9969 DECL_ANCHOR(inner_pre);
9970 scope_node->pre_execution_anchor = inner_pre;
9971
9972 DECL_ANCHOR(inner_body);
9973
9974 if (cast->statements != NULL) {
9975 const pm_node_list_t *body = &cast->statements->body;
9976
9977 for (size_t index = 0; index < body->size; index++) {
9978 pm_compile_node(iseq, body->nodes[index], inner_body, true, scope_node);
9979 }
9980 }
9981
9982 if (!popped) {
9983 PUSH_INSN(inner_body, location, putnil);
9984 }
9985
9986 // Now that everything has been compiled, join both anchors together
9987 // into the correct outer pre execution anchor, and reset the value so
9988 // that subsequent BEGIN{} nodes can be compiled correctly.
9989 PUSH_SEQ(outer_pre, inner_pre);
9990 PUSH_SEQ(outer_pre, inner_body);
9991 scope_node->pre_execution_anchor = outer_pre;
9992
9993 return;
9994 }
9995 case PM_POST_EXECUTION_NODE: {
9996 // END {}
9997 // ^^^^^^
9998 const rb_iseq_t *child_iseq;
9999 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
10000
10001 pm_scope_node_t next_scope_node;
10002 pm_scope_node_init(node, &next_scope_node, scope_node);
10003 child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno);
10004 pm_scope_node_destroy(&next_scope_node);
10005
10006 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
10007
10008 int is_index = ISEQ_BODY(iseq)->ise_size++;
10009 PUSH_INSN2(ret, location, once, child_iseq, INT2FIX(is_index));
10010 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) child_iseq);
10011 if (popped) PUSH_INSN(ret, location, pop);
10012
10013 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
10014
10015 return;
10016 }
10017 case PM_RANGE_NODE: {
10018 // 0..5
10019 // ^^^^
10020 const pm_range_node_t *cast = (const pm_range_node_t *) node;
10021 bool exclude_end = PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END);
10022
10023 if (pm_optimizable_range_item_p(cast->left) && pm_optimizable_range_item_p(cast->right)) {
10024 if (!popped) {
10025 const pm_node_t *left = cast->left;
10026 const pm_node_t *right = cast->right;
10027
10028 VALUE val = rb_range_new(
10029 (left && PM_NODE_TYPE_P(left, PM_INTEGER_NODE)) ? parse_integer((const pm_integer_node_t *) left) : Qnil,
10030 (right && PM_NODE_TYPE_P(right, PM_INTEGER_NODE)) ? parse_integer((const pm_integer_node_t *) right) : Qnil,
10031 exclude_end
10032 );
10033
10034 PUSH_INSN1(ret, location, putobject, val);
10035 }
10036 }
10037 else {
10038 if (cast->left != NULL) {
10039 PM_COMPILE(cast->left);
10040 }
10041 else if (!popped) {
10042 PUSH_INSN(ret, location, putnil);
10043 }
10044
10045 if (cast->right != NULL) {
10046 PM_COMPILE(cast->right);
10047 }
10048 else if (!popped) {
10049 PUSH_INSN(ret, location, putnil);
10050 }
10051
10052 if (!popped) {
10053 PUSH_INSN1(ret, location, newrange, INT2FIX(exclude_end ? 1 : 0));
10054 }
10055 }
10056 return;
10057 }
10058 case PM_RATIONAL_NODE: {
10059 // 1r
10060 // ^^
10061 if (!popped) {
10062 PUSH_INSN1(ret, location, putobject, parse_rational((const pm_rational_node_t *) node));
10063 }
10064 return;
10065 }
10066 case PM_REDO_NODE:
10067 // redo
10068 // ^^^^
10069 pm_compile_redo_node(iseq, &location, ret, popped, scope_node);
10070 return;
10071 case PM_REGULAR_EXPRESSION_NODE: {
10072 // /foo/
10073 // ^^^^^
10074 if (!popped) {
10075 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
10076 PUSH_INSN1(ret, location, putobject, regexp);
10077 }
10078 return;
10079 }
10080 case PM_RESCUE_NODE:
10081 // begin; rescue; end
10082 // ^^^^^^^
10083 pm_compile_rescue_node(iseq, (const pm_rescue_node_t *) node, &location, ret, popped, scope_node);
10084 return;
10085 case PM_RESCUE_MODIFIER_NODE: {
10086 // foo rescue bar
10087 // ^^^^^^^^^^^^^^
10088 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
10089
10090 pm_scope_node_t rescue_scope_node;
10091 pm_scope_node_init((const pm_node_t *) cast, &rescue_scope_node, scope_node);
10092
10093 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
10094 &rescue_scope_node,
10095 rb_str_concat(rb_str_new2("rescue in "), ISEQ_BODY(iseq)->location.label),
10096 ISEQ_TYPE_RESCUE,
10097 pm_node_line_number(parser, cast->rescue_expression)
10098 );
10099
10100 pm_scope_node_destroy(&rescue_scope_node);
10101
10102 LABEL *lstart = NEW_LABEL(location.line);
10103 LABEL *lend = NEW_LABEL(location.line);
10104 LABEL *lcont = NEW_LABEL(location.line);
10105
10106 lstart->rescued = LABEL_RESCUE_BEG;
10107 lend->rescued = LABEL_RESCUE_END;
10108
10109 PUSH_LABEL(ret, lstart);
10110 PM_COMPILE_NOT_POPPED(cast->expression);
10111 PUSH_LABEL(ret, lend);
10112
10113 PUSH_INSN(ret, location, nop);
10114 PUSH_LABEL(ret, lcont);
10115 if (popped) PUSH_INSN(ret, location, pop);
10116
10117 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
10118 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
10119 return;
10120 }
10121 case PM_RETURN_NODE:
10122 // return
10123 // ^^^^^^
10124 //
10125 // return 1
10126 // ^^^^^^^^
10127 pm_compile_return_node(iseq, (const pm_return_node_t *) node, &location, ret, popped, scope_node);
10128 return;
10129 case PM_RETRY_NODE: {
10130 // retry
10131 // ^^^^^
10132 if (ISEQ_BODY(iseq)->type == ISEQ_TYPE_RESCUE) {
10133 PUSH_INSN(ret, location, putnil);
10134 PUSH_INSN1(ret, location, throw, INT2FIX(TAG_RETRY));
10135 if (popped) PUSH_INSN(ret, location, pop);
10136 }
10137 else {
10138 COMPILE_ERROR(iseq, location.line, "Invalid retry");
10139 return;
10140 }
10141 return;
10142 }
10143 case PM_SCOPE_NODE:
10144 pm_compile_scope_node(iseq, (pm_scope_node_t *) node, &location, ret, popped);
10145 return;
10146 case PM_SELF_NODE: {
10147 // self
10148 // ^^^^
10149 if (!popped) {
10150 PUSH_INSN(ret, location, putself);
10151 }
10152 return;
10153 }
10154 case PM_SHAREABLE_CONSTANT_NODE: {
10155 // A value that is being written to a constant that is being marked as
10156 // shared depending on the current lexical context.
10157 const pm_shareable_constant_node_t *cast = (const pm_shareable_constant_node_t *) node;
10158 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));
10159
10160 switch (PM_NODE_TYPE(cast->write)) {
10161 case PM_CONSTANT_WRITE_NODE:
10162 pm_compile_constant_write_node(iseq, (const pm_constant_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10163 break;
10164 case PM_CONSTANT_AND_WRITE_NODE:
10165 pm_compile_constant_and_write_node(iseq, (const pm_constant_and_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10166 break;
10167 case PM_CONSTANT_OR_WRITE_NODE:
10168 pm_compile_constant_or_write_node(iseq, (const pm_constant_or_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10169 break;
10170 case PM_CONSTANT_OPERATOR_WRITE_NODE:
10171 pm_compile_constant_operator_write_node(iseq, (const pm_constant_operator_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10172 break;
10173 case PM_CONSTANT_PATH_WRITE_NODE:
10174 pm_compile_constant_path_write_node(iseq, (const pm_constant_path_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10175 break;
10176 case PM_CONSTANT_PATH_AND_WRITE_NODE:
10177 pm_compile_constant_path_and_write_node(iseq, (const pm_constant_path_and_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10178 break;
10179 case PM_CONSTANT_PATH_OR_WRITE_NODE:
10180 pm_compile_constant_path_or_write_node(iseq, (const pm_constant_path_or_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10181 break;
10182 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE:
10183 pm_compile_constant_path_operator_write_node(iseq, (const pm_constant_path_operator_write_node_t *) cast->write, shareability, &location, ret, popped, scope_node);
10184 break;
10185 default:
10186 rb_bug("Unexpected node type for shareable constant write: %s", pm_node_type_to_str(PM_NODE_TYPE(cast->write)));
10187 break;
10188 }
10189
10190 return;
10191 }
10192 case PM_SINGLETON_CLASS_NODE: {
10193 // class << self; end
10194 // ^^^^^^^^^^^^^^^^^^
10195 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
10196
10197 pm_scope_node_t next_scope_node;
10198 pm_scope_node_init((const pm_node_t *) cast, &next_scope_node, scope_node);
10199 const rb_iseq_t *child_iseq = NEW_ISEQ(&next_scope_node, rb_fstring_lit("singleton class"), ISEQ_TYPE_CLASS, location.line);
10200 pm_scope_node_destroy(&next_scope_node);
10201
10202 PM_COMPILE_NOT_POPPED(cast->expression);
10203 PUSH_INSN(ret, location, putnil);
10204
10205 ID singletonclass;
10206 CONST_ID(singletonclass, "singletonclass");
10207 PUSH_INSN3(ret, location, defineclass, ID2SYM(singletonclass), child_iseq, INT2FIX(VM_DEFINECLASS_TYPE_SINGLETON_CLASS));
10208
10209 if (popped) PUSH_INSN(ret, location, pop);
10210 RB_OBJ_WRITTEN(iseq, Qundef, (VALUE) child_iseq);
10211
10212 return;
10213 }
10214 case PM_SOURCE_ENCODING_NODE: {
10215 // __ENCODING__
10216 // ^^^^^^^^^^^^
10217 if (!popped) {
10218 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10219 PUSH_INSN1(ret, location, putobject, value);
10220 }
10221 return;
10222 }
10223 case PM_SOURCE_FILE_NODE: {
10224 // __FILE__
10225 // ^^^^^^^^
10226 if (!popped) {
10227 const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
10228 VALUE string = pm_source_file_value(cast, scope_node);
10229
10230 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
10231 PUSH_INSN1(ret, location, putobject, string);
10232 }
10233 else if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
10234 PUSH_INSN1(ret, location, putstring, string);
10235 }
10236 else {
10237 PUSH_INSN1(ret, location, putchilledstring, string);
10238 }
10239 }
10240 return;
10241 }
10242 case PM_SOURCE_LINE_NODE: {
10243 // __LINE__
10244 // ^^^^^^^^
10245 if (!popped) {
10246 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10247 PUSH_INSN1(ret, location, putobject, value);
10248 }
10249 return;
10250 }
10251 case PM_SPLAT_NODE: {
10252 // foo(*bar)
10253 // ^^^^
10254 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
10255 if (cast->expression) {
10256 PM_COMPILE(cast->expression);
10257 }
10258
10259 if (!popped) {
10260 PUSH_INSN1(ret, location, splatarray, Qtrue);
10261 }
10262 return;
10263 }
10264 case PM_STATEMENTS_NODE: {
10265 // A list of statements.
10266 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
10267 const pm_node_list_t *body = &cast->body;
10268
10269 if (body->size > 0) {
10270 for (size_t index = 0; index < body->size - 1; index++) {
10271 PM_COMPILE_POPPED(body->nodes[index]);
10272 }
10273 PM_COMPILE(body->nodes[body->size - 1]);
10274 }
10275 else {
10276 PUSH_INSN(ret, location, putnil);
10277 }
10278 return;
10279 }
10280 case PM_STRING_NODE: {
10281 // "foo"
10282 // ^^^^^
10283 if (!popped) {
10284 const pm_string_node_t *cast = (const pm_string_node_t *) node;
10285 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
10286
10287 if (PM_NODE_FLAG_P(node, PM_STRING_FLAGS_FROZEN)) {
10288 PUSH_INSN1(ret, location, putobject, value);
10289 }
10290 else if (PM_NODE_FLAG_P(node, PM_STRING_FLAGS_MUTABLE)) {
10291 PUSH_INSN1(ret, location, putstring, value);
10292 }
10293 else {
10294 PUSH_INSN1(ret, location, putchilledstring, value);
10295 }
10296 }
10297 return;
10298 }
10299 case PM_SUPER_NODE:
10300 // super()
10301 // super(foo)
10302 // super(...)
10303 pm_compile_super_node(iseq, (const pm_super_node_t *) node, &location, ret, popped, scope_node);
10304 return;
10305 case PM_SYMBOL_NODE: {
10306 // :foo
10307 // ^^^^
10308 if (!popped) {
10309 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10310 PUSH_INSN1(ret, location, putobject, value);
10311 }
10312 return;
10313 }
10314 case PM_TRUE_NODE: {
10315 // true
10316 // ^^^^
10317 if (!popped) {
10318 PUSH_INSN1(ret, location, putobject, Qtrue);
10319 }
10320 return;
10321 }
10322 case PM_UNDEF_NODE: {
10323 // undef foo
10324 // ^^^^^^^^^
10325 const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
10326 const pm_node_list_t *names = &cast->names;
10327
10328 for (size_t index = 0; index < names->size; index++) {
10329 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
10330 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));
10331
10332 PM_COMPILE_NOT_POPPED(names->nodes[index]);
10333 PUSH_SEND(ret, location, id_core_undef_method, INT2NUM(2));
10334
10335 if (index < names->size - 1) {
10336 PUSH_INSN(ret, location, pop);
10337 }
10338 }
10339
10340 if (popped) PUSH_INSN(ret, location, pop);
10341 return;
10342 }
10343 case PM_UNLESS_NODE: {
10344 // unless foo; bar end
10345 // ^^^^^^^^^^^^^^^^^^^
10346 //
10347 // bar unless foo
10348 // ^^^^^^^^^^^^^^
10349 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
10350 const pm_statements_node_t *statements = NULL;
10351 if (cast->else_clause != NULL) {
10352 statements = ((const pm_else_node_t *) cast->else_clause)->statements;
10353 }
10354
10355 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);
10356 return;
10357 }
10358 case PM_UNTIL_NODE: {
10359 // until foo; bar end
10360 // ^^^^^^^^^^^^^^^^^
10361 //
10362 // bar until foo
10363 // ^^^^^^^^^^^^^
10364 const pm_until_node_t *cast = (const pm_until_node_t *) node;
10365 pm_compile_loop(iseq, &location, cast->base.flags, PM_UNTIL_NODE, (const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10366 return;
10367 }
10368 case PM_WHILE_NODE: {
10369 // while foo; bar end
10370 // ^^^^^^^^^^^^^^^^^^
10371 //
10372 // bar while foo
10373 // ^^^^^^^^^^^^^
10374 const pm_while_node_t *cast = (const pm_while_node_t *) node;
10375 pm_compile_loop(iseq, &location, cast->base.flags, PM_WHILE_NODE, (const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10376 return;
10377 }
10378 case PM_X_STRING_NODE: {
10379 // `foo`
10380 // ^^^^^
10381 const pm_x_string_node_t *cast = (const pm_x_string_node_t *) node;
10382 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->unescaped);
10383
10384 PUSH_INSN(ret, location, putself);
10385 PUSH_INSN1(ret, location, putobject, value);
10386 PUSH_SEND_WITH_FLAG(ret, location, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
10387 if (popped) PUSH_INSN(ret, location, pop);
10388
10389 return;
10390 }
10391 case PM_YIELD_NODE:
10392 // yield
10393 // ^^^^^
10394 //
10395 // yield 1
10396 // ^^^^^^^
10397 pm_compile_yield_node(iseq, (const pm_yield_node_t *) node, &location, ret, popped, scope_node);
10398 return;
10399 default:
10400 rb_raise(rb_eNotImpError, "node type %s not implemented", pm_node_type_to_str(PM_NODE_TYPE(node)));
10401 return;
10402 }
10403}
10404
10405#undef PM_CONTAINER_P
10406
10408static inline bool
10409pm_iseq_pre_execution_p(rb_iseq_t *iseq)
10410{
10411 switch (ISEQ_BODY(iseq)->type) {
10412 case ISEQ_TYPE_TOP:
10413 case ISEQ_TYPE_EVAL:
10414 case ISEQ_TYPE_MAIN:
10415 return true;
10416 default:
10417 return false;
10418 }
10419}
10420
10428 VALUE
10429pm_iseq_compile_node(rb_iseq_t *iseq, pm_scope_node_t *node)
10430{
10431 DECL_ANCHOR(ret);
10432
10433 if (pm_iseq_pre_execution_p(iseq)) {
10434 // Because these ISEQs can have BEGIN{}, we're going to create two
10435 // anchors to compile them, a "pre" and a "body". We'll mark the "pre"
10436 // on the scope node so that when BEGIN{} is found, its contents will be
10437 // added to the "pre" anchor.
10438 DECL_ANCHOR(pre);
10439 node->pre_execution_anchor = pre;
10440
10441 // Now we'll compile the body as normal. We won't compile directly into
10442 // the "ret" anchor yet because we want to add the "pre" anchor to the
10443 // beginning of the "ret" anchor first.
10444 DECL_ANCHOR(body);
10445 pm_compile_node(iseq, (const pm_node_t *) node, body, false, node);
10446
10447 // Now we'll join both anchors together so that the content is in the
10448 // correct order.
10449 PUSH_SEQ(ret, pre);
10450 PUSH_SEQ(ret, body);
10451 }
10452 else {
10453 // In other circumstances, we can just compile the node directly into
10454 // the "ret" anchor.
10455 pm_compile_node(iseq, (const pm_node_t *) node, ret, false, node);
10456 }
10457
10458 CHECK(iseq_setup_insn(iseq, ret));
10459 return iseq_setup(iseq, ret);
10460}
10461
10466void
10467pm_parse_result_free(pm_parse_result_t *result)
10468{
10469 if (result->node.ast_node != NULL) {
10470 pm_node_destroy(&result->parser, result->node.ast_node);
10471 }
10472
10473 if (result->parsed) {
10474 xfree(result->node.constants);
10475 pm_scope_node_destroy(&result->node);
10476 }
10477
10478 pm_parser_free(&result->parser);
10479 pm_string_free(&result->input);
10480 pm_options_free(&result->options);
10481}
10482
10484 typedef struct {
10486 pm_diagnostic_t *error;
10487
10489 int32_t line;
10490
10492 uint32_t column_start;
10493
10495 uint32_t column_end;
10496} pm_parse_error_t;
10497
10499 typedef struct {
10501 const char *number_prefix;
10502
10504 const char *blank_prefix;
10505
10507 const char *divider;
10508
10510 size_t blank_prefix_length;
10511
10513 size_t divider_length;
10514} pm_parse_error_format_t;
10515
10516#define PM_COLOR_BOLD "\033[1m"
10517#define PM_COLOR_GRAY "\033[2m"
10518#define PM_COLOR_RED "\033[1;31m"
10519#define PM_COLOR_RESET "\033[m"
10520#define PM_ERROR_TRUNCATE 30
10521
10522static inline pm_parse_error_t *
10523pm_parse_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_list, const pm_newline_list_t *newline_list) {
10524 pm_parse_error_t *errors = xcalloc(error_list->size, sizeof(pm_parse_error_t));
10525 if (errors == NULL) return NULL;
10526
10527 int32_t start_line = parser->start_line;
10528 for (pm_diagnostic_t *error = (pm_diagnostic_t *) error_list->head; error != NULL; error = (pm_diagnostic_t *) error->node.next) {
10529 pm_line_column_t start = pm_newline_list_line_column(newline_list, error->location.start, start_line);
10530 pm_line_column_t end = pm_newline_list_line_column(newline_list, error->location.end, start_line);
10531
10532 // We're going to insert this error into the array in sorted order. We
10533 // do this by finding the first error that has a line number greater
10534 // than the current error and then inserting the current error before
10535 // that one.
10536 size_t index = 0;
10537 while (
10538 (index < error_list->size) &&
10539 (errors[index].error != NULL) &&
10540 (
10541 (errors[index].line < start.line) ||
10542 ((errors[index].line == start.line) && (errors[index].column_start < start.column))
10543 )
10544 ) index++;
10545
10546 // Now we're going to shift all of the errors after this one down one
10547 // index to make room for the new error.
10548 if (index + 1 < error_list->size) {
10549 memmove(&errors[index + 1], &errors[index], sizeof(pm_parse_error_t) * (error_list->size - index - 1));
10550 }
10551
10552 // Finally, we'll insert the error into the array.
10553 uint32_t column_end;
10554 if (start.line == end.line) {
10555 column_end = end.column;
10556 } else {
10557 column_end = (uint32_t) (newline_list->offsets[start.line - start_line + 1] - newline_list->offsets[start.line - start_line] - 1);
10558 }
10559
10560 // Ensure we have at least one column of error.
10561 if (start.column == column_end) column_end++;
10562
10563 errors[index] = (pm_parse_error_t) {
10564 .error = error,
10565 .line = start.line,
10566 .column_start = start.column,
10567 .column_end = column_end
10568 };
10569 }
10570
10571 return errors;
10572}
10573
10574/* Append a literal string to the buffer. */
10575#define pm_buffer_append_literal(buffer, str) pm_buffer_append_string(buffer, str, rb_strlen_lit(str))
10576
10577static inline void
10578pm_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) {
10579 int32_t line_delta = line - parser->start_line;
10580 assert(line_delta >= 0);
10581
10582 size_t index = (size_t) line_delta;
10583 assert(index < newline_list->size);
10584
10585 const uint8_t *start = &parser->start[newline_list->offsets[index]];
10586 const uint8_t *end;
10587
10588 if (index >= newline_list->size - 1) {
10589 end = parser->end;
10590 } else {
10591 end = &parser->start[newline_list->offsets[index + 1]];
10592 }
10593
10594 pm_buffer_append_format(buffer, number_prefix, line);
10595
10596 // Here we determine if we should truncate the end of the line.
10597 bool truncate_end = false;
10598 if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
10599 end = start + column_end + PM_ERROR_TRUNCATE;
10600 truncate_end = true;
10601 }
10602
10603 // Here we determine if we should truncate the start of the line.
10604 if (column_start >= PM_ERROR_TRUNCATE) {
10605 pm_buffer_append_string(buffer, "... ", 4);
10606 start += column_start;
10607 }
10608
10609 pm_buffer_append_string(buffer, (const char *) start, (size_t) (end - start));
10610
10611 if (truncate_end) {
10612 pm_buffer_append_string(buffer, " ...\n", 5);
10613 } else if (end == parser->end && end[-1] != '\n') {
10614 pm_buffer_append_string(buffer, "\n", 1);
10615 }
10616}
10617
10621static void
10622pm_parse_errors_format(const pm_parser_t *parser, const pm_list_t *error_list, pm_buffer_t *buffer, int highlight, bool inline_messages) {
10623 assert(error_list->size != 0);
10624
10625 // First, we're going to sort all of the errors by line number using an
10626 // insertion sort into a newly allocated array.
10627 const int32_t start_line = parser->start_line;
10628 const pm_newline_list_t *newline_list = &parser->newline_list;
10629
10630 pm_parse_error_t *errors = pm_parse_errors_format_sort(parser, error_list, newline_list);
10631 if (errors == NULL) return;
10632
10633 // Now we're going to determine how we're going to format line numbers and
10634 // blank lines based on the maximum number of digits in the line numbers
10635 // that are going to be displaid.
10636 pm_parse_error_format_t error_format;
10637 int32_t first_line_number = errors[0].line;
10638 int32_t last_line_number = errors[error_list->size - 1].line;
10639
10640 // If we have a maximum line number that is negative, then we're going to
10641 // use the absolute value for comparison but multiple by 10 to additionally
10642 // have a column for the negative sign.
10643 if (first_line_number < 0) first_line_number = (-first_line_number) * 10;
10644 if (last_line_number < 0) last_line_number = (-last_line_number) * 10;
10645 int32_t max_line_number = first_line_number > last_line_number ? first_line_number : last_line_number;
10646
10647 if (max_line_number < 10) {
10648 if (highlight > 0) {
10649 error_format = (pm_parse_error_format_t) {
10650 .number_prefix = PM_COLOR_GRAY "%1" PRIi32 " | " PM_COLOR_RESET,
10651 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10652 .divider = PM_COLOR_GRAY " ~~~~~" PM_COLOR_RESET "\n"
10653 };
10654 } else {
10655 error_format = (pm_parse_error_format_t) {
10656 .number_prefix = "%1" PRIi32 " | ",
10657 .blank_prefix = " | ",
10658 .divider = " ~~~~~\n"
10659 };
10660 }
10661 } else if (max_line_number < 100) {
10662 if (highlight > 0) {
10663 error_format = (pm_parse_error_format_t) {
10664 .number_prefix = PM_COLOR_GRAY "%2" PRIi32 " | " PM_COLOR_RESET,
10665 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10666 .divider = PM_COLOR_GRAY " ~~~~~~" PM_COLOR_RESET "\n"
10667 };
10668 } else {
10669 error_format = (pm_parse_error_format_t) {
10670 .number_prefix = "%2" PRIi32 " | ",
10671 .blank_prefix = " | ",
10672 .divider = " ~~~~~~\n"
10673 };
10674 }
10675 } else if (max_line_number < 1000) {
10676 if (highlight > 0) {
10677 error_format = (pm_parse_error_format_t) {
10678 .number_prefix = PM_COLOR_GRAY "%3" PRIi32 " | " PM_COLOR_RESET,
10679 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10680 .divider = PM_COLOR_GRAY " ~~~~~~~" PM_COLOR_RESET "\n"
10681 };
10682 } else {
10683 error_format = (pm_parse_error_format_t) {
10684 .number_prefix = "%3" PRIi32 " | ",
10685 .blank_prefix = " | ",
10686 .divider = " ~~~~~~~\n"
10687 };
10688 }
10689 } else if (max_line_number < 10000) {
10690 if (highlight > 0) {
10691 error_format = (pm_parse_error_format_t) {
10692 .number_prefix = PM_COLOR_GRAY "%4" PRIi32 " | " PM_COLOR_RESET,
10693 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10694 .divider = PM_COLOR_GRAY " ~~~~~~~~" PM_COLOR_RESET "\n"
10695 };
10696 } else {
10697 error_format = (pm_parse_error_format_t) {
10698 .number_prefix = "%4" PRIi32 " | ",
10699 .blank_prefix = " | ",
10700 .divider = " ~~~~~~~~\n"
10701 };
10702 }
10703 } else {
10704 if (highlight > 0) {
10705 error_format = (pm_parse_error_format_t) {
10706 .number_prefix = PM_COLOR_GRAY "%5" PRIi32 " | " PM_COLOR_RESET,
10707 .blank_prefix = PM_COLOR_GRAY " | " PM_COLOR_RESET,
10708 .divider = PM_COLOR_GRAY " ~~~~~~~~" PM_COLOR_RESET "\n"
10709 };
10710 } else {
10711 error_format = (pm_parse_error_format_t) {
10712 .number_prefix = "%5" PRIi32 " | ",
10713 .blank_prefix = " | ",
10714 .divider = " ~~~~~~~~\n"
10715 };
10716 }
10717 }
10718
10719 error_format.blank_prefix_length = strlen(error_format.blank_prefix);
10720 error_format.divider_length = strlen(error_format.divider);
10721
10722 // Now we're going to iterate through every error in our error list and
10723 // display it. While we're iterating, we will display some padding lines of
10724 // the source before the error to give some context. We'll be careful not to
10725 // display the same line twice in case the errors are close enough in the
10726 // source.
10727 int32_t last_line = parser->start_line - 1;
10728 uint32_t last_column_start = 0;
10729 const pm_encoding_t *encoding = parser->encoding;
10730
10731 for (size_t index = 0; index < error_list->size; index++) {
10732 pm_parse_error_t *error = &errors[index];
10733
10734 // Here we determine how many lines of padding of the source to display,
10735 // based on the difference from the last line that was displaid.
10736 if (error->line - last_line > 1) {
10737 if (error->line - last_line > 2) {
10738 if ((index != 0) && (error->line - last_line > 3)) {
10739 pm_buffer_append_string(buffer, error_format.divider, error_format.divider_length);
10740 }
10741
10742 pm_buffer_append_string(buffer, " ", 2);
10743 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 2, 0, 0, buffer);
10744 }
10745
10746 pm_buffer_append_string(buffer, " ", 2);
10747 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line - 1, 0, 0, buffer);
10748 }
10749
10750 // If this is the first error or we're on a new line, then we'll display
10751 // the line that has the error in it.
10752 if ((index == 0) || (error->line != last_line)) {
10753 if (highlight > 1) {
10754 pm_buffer_append_literal(buffer, PM_COLOR_RED "> " PM_COLOR_RESET);
10755 } else if (highlight > 0) {
10756 pm_buffer_append_literal(buffer, PM_COLOR_BOLD "> " PM_COLOR_RESET);
10757 } else {
10758 pm_buffer_append_literal(buffer, "> ");
10759 }
10760
10761 last_column_start = error->column_start;
10762
10763 // Find the maximum column end of all the errors on this line.
10764 uint32_t column_end = error->column_end;
10765 for (size_t next_index = index + 1; next_index < error_list->size; next_index++) {
10766 if (errors[next_index].line != error->line) break;
10767 if (errors[next_index].column_end > column_end) column_end = errors[next_index].column_end;
10768 }
10769
10770 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, error->line, error->column_start, column_end, buffer);
10771 }
10772
10773 const uint8_t *start = &parser->start[newline_list->offsets[error->line - start_line]];
10774 if (start == parser->end) pm_buffer_append_byte(buffer, '\n');
10775
10776 // Now we'll display the actual error message. We'll do this by first
10777 // putting the prefix to the line, then a bunch of blank spaces
10778 // depending on the column, then as many carets as we need to display
10779 // the width of the error, then the error message itself.
10780 //
10781 // Note that this doesn't take into account the width of the actual
10782 // character when displaid in the terminal. For some east-asian
10783 // languages or emoji, this means it can be thrown off pretty badly. We
10784 // will need to solve this eventually.
10785 pm_buffer_append_string(buffer, " ", 2);
10786 pm_buffer_append_string(buffer, error_format.blank_prefix, error_format.blank_prefix_length);
10787
10788 size_t column = 0;
10789 if (last_column_start >= PM_ERROR_TRUNCATE) {
10790 pm_buffer_append_string(buffer, " ", 4);
10791 column = last_column_start;
10792 }
10793
10794 while (column < error->column_start) {
10795 pm_buffer_append_byte(buffer, ' ');
10796
10797 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10798 column += (char_width == 0 ? 1 : char_width);
10799 }
10800
10801 if (highlight > 1) pm_buffer_append_literal(buffer, PM_COLOR_RED);
10802 else if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_BOLD);
10803 pm_buffer_append_byte(buffer, '^');
10804
10805 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10806 column += (char_width == 0 ? 1 : char_width);
10807
10808 while (column < error->column_end) {
10809 pm_buffer_append_byte(buffer, '~');
10810
10811 size_t char_width = encoding->char_width(start + column, parser->end - (start + column));
10812 column += (char_width == 0 ? 1 : char_width);
10813 }
10814
10815 if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_RESET);
10816
10817 if (inline_messages) {
10818 pm_buffer_append_byte(buffer, ' ');
10819 assert(error->error != NULL);
10820
10821 const char *message = error->error->message;
10822 pm_buffer_append_string(buffer, message, strlen(message));
10823 }
10824
10825 pm_buffer_append_byte(buffer, '\n');
10826
10827 // Here we determine how many lines of padding to display after the
10828 // error, depending on where the next error is in source.
10829 last_line = error->line;
10830 int32_t next_line;
10831
10832 if (index == error_list->size - 1) {
10833 next_line = (((int32_t) newline_list->size) + parser->start_line);
10834
10835 // If the file ends with a newline, subtract one from our "next_line"
10836 // so that we don't output an extra line at the end of the file
10837 if ((parser->start + newline_list->offsets[newline_list->size - 1]) == parser->end) {
10838 next_line--;
10839 }
10840 }
10841 else {
10842 next_line = errors[index + 1].line;
10843 }
10844
10845 if (next_line - last_line > 1) {
10846 pm_buffer_append_string(buffer, " ", 2);
10847 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
10848 }
10849
10850 if (next_line - last_line > 1) {
10851 pm_buffer_append_string(buffer, " ", 2);
10852 pm_parse_errors_format_line(parser, newline_list, error_format.number_prefix, ++last_line, 0, 0, buffer);
10853 }
10854 }
10855
10856 // Finally, we'll free the array of errors that we allocated.
10857 xfree(errors);
10858}
10859
10860#undef PM_ERROR_TRUNCATE
10861#undef PM_COLOR_GRAY
10862#undef PM_COLOR_RED
10863#undef PM_COLOR_RESET
10864
10871static bool
10872pm_parse_process_error_utf8_p(const pm_parser_t *parser, const pm_location_t *location)
10873{
10874 const size_t start_line = pm_newline_list_line_column(&parser->newline_list, location->start, 1).line;
10875 const size_t end_line = pm_newline_list_line_column(&parser->newline_list, location->end, 1).line;
10876
10877 const uint8_t *start = parser->start + parser->newline_list.offsets[start_line - 1];
10878 const uint8_t *end = ((end_line == parser->newline_list.size) ? parser->end : (parser->start + parser->newline_list.offsets[end_line]));
10879 size_t width;
10880
10881 while (start < end) {
10882 if ((width = pm_encoding_utf_8_char_width(start, end - start)) == 0) return false;
10883 start += width;
10884 }
10885
10886 return true;
10887}
10888
10893static VALUE
10894pm_parse_process_error(const pm_parse_result_t *result)
10895{
10896 const pm_parser_t *parser = &result->parser;
10897 const pm_diagnostic_t *head = (const pm_diagnostic_t *) parser->error_list.head;
10898 bool valid_utf8 = true;
10899
10900 pm_buffer_t buffer = { 0 };
10901 const pm_string_t *filepath = &parser->filepath;
10902
10903 int highlight = rb_stderr_tty_p();
10904 if (highlight) {
10905 const char *no_color = getenv("NO_COLOR");
10906 highlight = (no_color == NULL || no_color[0] == '\0') ? 2 : 1;
10907 }
10908
10909 for (const pm_diagnostic_t *error = head; error != NULL; error = (const pm_diagnostic_t *) error->node.next) {
10910 switch (error->level) {
10911 case PM_ERROR_LEVEL_SYNTAX:
10912 // It is implicitly assumed that the error messages will be
10913 // encodeable as UTF-8. Because of this, we can't include source
10914 // examples that contain invalid byte sequences. So if any source
10915 // examples include invalid UTF-8 byte sequences, we will skip
10916 // showing source examples entirely.
10917 if (valid_utf8 && !pm_parse_process_error_utf8_p(parser, &error->location)) {
10918 valid_utf8 = false;
10919 }
10920 break;
10921 case PM_ERROR_LEVEL_ARGUMENT: {
10922 // Any errors with the level PM_ERROR_LEVEL_ARGUMENT take over as
10923 // the only argument that gets raised. This is to allow priority
10924 // messages that should be handled before anything else.
10925 int32_t line_number = (int32_t) pm_location_line_number(parser, &error->location);
10926
10927 pm_buffer_append_format(
10928 &buffer,
10929 "%.*s:%" PRIi32 ": %s",
10930 (int) pm_string_length(filepath),
10931 pm_string_source(filepath),
10932 line_number,
10933 error->message
10934 );
10935
10936 if (pm_parse_process_error_utf8_p(parser, &error->location)) {
10937 pm_buffer_append_byte(&buffer, '\n');
10938
10939 pm_list_node_t *list_node = (pm_list_node_t *) error;
10940 pm_list_t error_list = { .size = 1, .head = list_node, .tail = list_node };
10941
10942 pm_parse_errors_format(parser, &error_list, &buffer, highlight, false);
10943 }
10944
10945 VALUE value = rb_exc_new(rb_eArgError, pm_buffer_value(&buffer), pm_buffer_length(&buffer));
10946 pm_buffer_free(&buffer);
10947
10948 return value;
10949 }
10950 case PM_ERROR_LEVEL_LOAD: {
10951 // Load errors are much simpler, because they don't include any of
10952 // the source in them. We create the error directly from the
10953 // message.
10954 VALUE message = rb_enc_str_new_cstr(error->message, rb_locale_encoding());
10955 VALUE value = rb_exc_new3(rb_eLoadError, message);
10956 rb_ivar_set(value, rb_intern_const("@path"), Qnil);
10957 return value;
10958 }
10959 }
10960 }
10961
10962 pm_buffer_append_format(
10963 &buffer,
10964 "%.*s:%" PRIi32 ": syntax error%s found\n",
10965 (int) pm_string_length(filepath),
10966 pm_string_source(filepath),
10967 (int32_t) pm_location_line_number(parser, &head->location),
10968 (parser->error_list.size > 1) ? "s" : ""
10969 );
10970
10971 if (valid_utf8) {
10972 pm_parse_errors_format(parser, &parser->error_list, &buffer, highlight, true);
10973 }
10974 else {
10975 for (const pm_diagnostic_t *error = head; error != NULL; error = (const pm_diagnostic_t *) error->node.next) {
10976 if (error != head) pm_buffer_append_byte(&buffer, '\n');
10977 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);
10978 }
10979 }
10980
10981 VALUE message = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), result->node.encoding);
10982 VALUE error = rb_exc_new_str(rb_eSyntaxError, message);
10983
10984 rb_encoding *filepath_encoding = result->node.filepath_encoding != NULL ? result->node.filepath_encoding : rb_utf8_encoding();
10985 VALUE path = rb_enc_str_new((const char *) pm_string_source(filepath), pm_string_length(filepath), filepath_encoding);
10986
10987 rb_ivar_set(error, rb_intern_const("@path"), path);
10988 pm_buffer_free(&buffer);
10989
10990 return error;
10991}
10992
10998static VALUE
10999pm_parse_process(pm_parse_result_t *result, pm_node_t *node, VALUE *script_lines)
11000{
11001 pm_parser_t *parser = &result->parser;
11002
11003 // First, set up the scope node so that the AST node is attached and can be
11004 // freed regardless of whether or we return an error.
11005 pm_scope_node_t *scope_node = &result->node;
11006 rb_encoding *filepath_encoding = scope_node->filepath_encoding;
11007 int coverage_enabled = scope_node->coverage_enabled;
11008
11009 pm_scope_node_init(node, scope_node, NULL);
11010 scope_node->filepath_encoding = filepath_encoding;
11011
11012 scope_node->encoding = rb_enc_find(parser->encoding->name);
11013 if (!scope_node->encoding) rb_bug("Encoding not found %s!", parser->encoding->name);
11014
11015 scope_node->coverage_enabled = coverage_enabled;
11016
11017 // If RubyVM.keep_script_lines is set to true, then we need to create that
11018 // array of script lines here.
11019 if (script_lines != NULL) {
11020 *script_lines = rb_ary_new_capa(parser->newline_list.size);
11021
11022 for (size_t index = 0; index < parser->newline_list.size; index++) {
11023 size_t offset = parser->newline_list.offsets[index];
11024 size_t length = index == parser->newline_list.size - 1 ? ((size_t) (parser->end - (parser->start + offset))) : (parser->newline_list.offsets[index + 1] - offset);
11025 rb_ary_push(*script_lines, rb_enc_str_new((const char *) parser->start + offset, length, scope_node->encoding));
11026 }
11027
11028 scope_node->script_lines = script_lines;
11029 }
11030
11031 // Emit all of the various warnings from the parse.
11032 const pm_diagnostic_t *warning;
11033 const char *warning_filepath = (const char *) pm_string_source(&parser->filepath);
11034
11035 for (warning = (const pm_diagnostic_t *) parser->warning_list.head; warning != NULL; warning = (const pm_diagnostic_t *) warning->node.next) {
11036 int line = pm_location_line_number(parser, &warning->location);
11037
11038 if (warning->level == PM_WARNING_LEVEL_VERBOSE) {
11039 rb_enc_compile_warning(scope_node->encoding, warning_filepath, line, "%s", warning->message);
11040 }
11041 else {
11042 rb_enc_compile_warn(scope_node->encoding, warning_filepath, line, "%s", warning->message);
11043 }
11044 }
11045
11046 // If there are errors, raise an appropriate error and free the result.
11047 if (parser->error_list.size > 0) {
11048 VALUE error = pm_parse_process_error(result);
11049
11050 // TODO: We need to set the backtrace.
11051 // rb_funcallv(error, rb_intern("set_backtrace"), 1, &path);
11052 return error;
11053 }
11054
11055 // Now set up the constant pool and intern all of the various constants into
11056 // their corresponding IDs.
11057 scope_node->parser = parser;
11058 scope_node->constants = xcalloc(parser->constant_pool.size, sizeof(ID));
11059
11060 for (uint32_t index = 0; index < parser->constant_pool.size; index++) {
11061 pm_constant_t *constant = &parser->constant_pool.constants[index];
11062 scope_node->constants[index] = rb_intern3((const char *) constant->start, constant->length, scope_node->encoding);
11063 }
11064
11065 scope_node->index_lookup_table = st_init_numtable();
11066 pm_constant_id_list_t *locals = &scope_node->locals;
11067 for (size_t index = 0; index < locals->size; index++) {
11068 st_insert(scope_node->index_lookup_table, locals->ids[index], index);
11069 }
11070
11071 // If we got here, this is a success and we can return Qnil to indicate that
11072 // no error should be raised.
11073 result->parsed = true;
11074 return Qnil;
11075}
11076
11081static void
11082pm_options_frozen_string_literal_init(pm_options_t *options)
11083{
11084 int frozen_string_literal = rb_iseq_opt_frozen_string_literal();
11085
11086 switch (frozen_string_literal) {
11087 case ISEQ_FROZEN_STRING_LITERAL_UNSET:
11088 break;
11089 case ISEQ_FROZEN_STRING_LITERAL_DISABLED:
11090 pm_options_frozen_string_literal_set(options, false);
11091 break;
11092 case ISEQ_FROZEN_STRING_LITERAL_ENABLED:
11093 pm_options_frozen_string_literal_set(options, true);
11094 break;
11095 default:
11096 rb_bug("pm_options_frozen_string_literal_init: invalid frozen_string_literal=%d", frozen_string_literal);
11097 break;
11098 }
11099}
11100
11105static inline VALUE
11106pm_parse_file_script_lines(const pm_scope_node_t *scope_node, const pm_parser_t *parser)
11107{
11108 const pm_newline_list_t *newline_list = &parser->newline_list;
11109 const char *start = (const char *) parser->start;
11110 const char *end = (const char *) parser->end;
11111
11112 // If we end exactly on a newline, then there's no need to push on a final
11113 // segment. If we don't, then we need to push on the last offset up to the
11114 // end of the string.
11115 size_t last_offset = newline_list->offsets[newline_list->size - 1];
11116 bool last_push = start + last_offset != end;
11117
11118 // Create the ruby strings that represent the lines of the source.
11119 VALUE lines = rb_ary_new_capa(newline_list->size - (last_push ? 0 : 1));
11120
11121 for (size_t index = 0; index < newline_list->size - 1; index++) {
11122 size_t offset = newline_list->offsets[index];
11123 size_t length = newline_list->offsets[index + 1] - offset;
11124
11125 rb_ary_push(lines, rb_enc_str_new(start + offset, length, scope_node->encoding));
11126 }
11127
11128 // Push on the last line if we need to.
11129 if (last_push) {
11130 rb_ary_push(lines, rb_enc_str_new(start + last_offset, end - (start + last_offset), scope_node->encoding));
11131 }
11132
11133 return lines;
11134}
11135
11136// This is essentially pm_string_mapped_init(), preferring to memory map the
11137// file, with additional handling for files that require blocking to properly
11138// read (e.g. pipes).
11139static pm_string_init_result_t
11140pm_read_file(pm_string_t *string, const char *filepath)
11141{
11142#ifdef _WIN32
11143 // Open the file for reading.
11144 int length = MultiByteToWideChar(CP_UTF8, 0, filepath, -1, NULL, 0);
11145 if (length == 0) return PM_STRING_INIT_ERROR_GENERIC;
11146
11147 WCHAR *wfilepath = xmalloc(sizeof(WCHAR) * ((size_t) length));
11148 if ((wfilepath == NULL) || (MultiByteToWideChar(CP_UTF8, 0, filepath, -1, wfilepath, length) == 0)) {
11149 xfree(wfilepath);
11150 return PM_STRING_INIT_ERROR_GENERIC;
11151 }
11152
11153 HANDLE file = CreateFileW(wfilepath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
11154 if (file == INVALID_HANDLE_VALUE) {
11155 pm_string_init_result_t result = PM_STRING_INIT_ERROR_GENERIC;
11156
11157 if (GetLastError() == ERROR_ACCESS_DENIED) {
11158 DWORD attributes = GetFileAttributesW(wfilepath);
11159 if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
11160 result = PM_STRING_INIT_ERROR_DIRECTORY;
11161 }
11162 }
11163
11164 xfree(wfilepath);
11165 return result;
11166 }
11167
11168 // Get the file size.
11169 DWORD file_size = GetFileSize(file, NULL);
11170 if (file_size == INVALID_FILE_SIZE) {
11171 CloseHandle(file);
11172 xfree(wfilepath);
11173 return PM_STRING_INIT_ERROR_GENERIC;
11174 }
11175
11176 // If the file is empty, then we don't need to do anything else, we'll set
11177 // the source to a constant empty string and return.
11178 if (file_size == 0) {
11179 CloseHandle(file);
11180 xfree(wfilepath);
11181 const uint8_t source[] = "";
11182 *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11183 return PM_STRING_INIT_SUCCESS;
11184 }
11185
11186 // Create a mapping of the file.
11187 HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
11188 if (mapping == NULL) {
11189 CloseHandle(file);
11190 xfree(wfilepath);
11191 return PM_STRING_INIT_ERROR_GENERIC;
11192 }
11193
11194 // Map the file into memory.
11195 uint8_t *source = (uint8_t *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
11196 CloseHandle(mapping);
11197 CloseHandle(file);
11198 xfree(wfilepath);
11199
11200 if (source == NULL) {
11201 return PM_STRING_INIT_ERROR_GENERIC;
11202 }
11203
11204 *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = (size_t) file_size };
11205 return PM_STRING_INIT_SUCCESS;
11206#elif defined(_POSIX_MAPPED_FILES)
11207 // Open the file for reading
11208 const int open_mode = O_RDONLY | O_NONBLOCK;
11209 int fd = open(filepath, open_mode);
11210 if (fd == -1) {
11211 return PM_STRING_INIT_ERROR_GENERIC;
11212 }
11213
11214 // Stat the file to get the file size
11215 struct stat sb;
11216 if (fstat(fd, &sb) == -1) {
11217 close(fd);
11218 return PM_STRING_INIT_ERROR_GENERIC;
11219 }
11220
11221 // Ensure it is a file and not a directory
11222 if (S_ISDIR(sb.st_mode)) {
11223 close(fd);
11224 return PM_STRING_INIT_ERROR_DIRECTORY;
11225 }
11226
11227 // We need to wait for data first before reading from pipes and character
11228 // devices. To not block the entire VM, we need to release the GVL while
11229 // reading. Use IO#read to do this and let the GC handle closing the FD.
11230 if (S_ISFIFO(sb.st_mode) || S_ISCHR(sb.st_mode)) {
11231 VALUE io = rb_io_fdopen((int) fd, open_mode, filepath);
11232 rb_io_wait(io, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
11233 VALUE contents = rb_funcall(io, rb_intern("read"), 0);
11234
11235 if (!RB_TYPE_P(contents, T_STRING)) {
11236 return PM_STRING_INIT_ERROR_GENERIC;
11237 }
11238
11239 long len = RSTRING_LEN(contents);
11240 if (len < 0) {
11241 return PM_STRING_INIT_ERROR_GENERIC;
11242 }
11243
11244 size_t length = (size_t) len;
11245 uint8_t *source = malloc(length);
11246 memcpy(source, RSTRING_PTR(contents), length);
11247 *string = (pm_string_t) { .type = PM_STRING_OWNED, .source = source, .length = length };
11248
11249 return PM_STRING_INIT_SUCCESS;
11250 }
11251
11252 // mmap the file descriptor to virtually get the contents
11253 size_t size = (size_t) sb.st_size;
11254 uint8_t *source = NULL;
11255
11256 if (size == 0) {
11257 close(fd);
11258 const uint8_t source[] = "";
11259 *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11260 return PM_STRING_INIT_SUCCESS;
11261 }
11262
11263 source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
11264 if (source == MAP_FAILED) {
11265 close(fd);
11266 return PM_STRING_INIT_ERROR_GENERIC;
11267 }
11268
11269 close(fd);
11270 *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = size };
11271 return PM_STRING_INIT_SUCCESS;
11272#else
11273 return pm_string_file_init(string, filepath);
11274#endif
11275}
11276
11281 VALUE
11282pm_load_file(pm_parse_result_t *result, VALUE filepath, bool load_error)
11283{
11284 pm_string_init_result_t init_result = pm_read_file(&result->input, RSTRING_PTR(filepath));
11285
11286 if (init_result == PM_STRING_INIT_SUCCESS) {
11287 pm_options_frozen_string_literal_init(&result->options);
11288 return Qnil;
11289 }
11290
11291 int err;
11292 if (init_result == PM_STRING_INIT_ERROR_DIRECTORY) {
11293 err = EISDIR;
11294 } else {
11295#ifdef _WIN32
11296 err = rb_w32_map_errno(GetLastError());
11297#else
11298 err = errno;
11299#endif
11300 }
11301
11302 VALUE error;
11303 if (load_error) {
11304 VALUE message = rb_str_buf_new_cstr(strerror(err));
11305 rb_str_cat2(message, " -- ");
11306 rb_str_append(message, filepath);
11307
11308 error = rb_exc_new3(rb_eLoadError, message);
11309 rb_ivar_set(error, rb_intern_const("@path"), filepath);
11310 } else {
11311 error = rb_syserr_new(err, RSTRING_PTR(filepath));
11312 RB_GC_GUARD(filepath);
11313 }
11314
11315 return error;
11316}
11317
11324 VALUE
11325pm_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
11326{
11327 result->node.filepath_encoding = rb_enc_get(filepath);
11328 pm_options_filepath_set(&result->options, RSTRING_PTR(filepath));
11329 RB_GC_GUARD(filepath);
11330
11331 pm_parser_init(&result->parser, pm_string_source(&result->input), pm_string_length(&result->input), &result->options);
11332 pm_node_t *node = pm_parse(&result->parser);
11333
11334 VALUE error = pm_parse_process(result, node, script_lines);
11335
11336 // If we're parsing a filepath, then we need to potentially support the
11337 // SCRIPT_LINES__ constant, which can be a hash that has an array of lines
11338 // of every read file.
11339 ID id_script_lines = rb_intern("SCRIPT_LINES__");
11340
11341 if (rb_const_defined_at(rb_cObject, id_script_lines)) {
11342 VALUE constant_script_lines = rb_const_get_at(rb_cObject, id_script_lines);
11343
11344 if (RB_TYPE_P(constant_script_lines, T_HASH)) {
11345 rb_hash_aset(constant_script_lines, filepath, pm_parse_file_script_lines(&result->node, &result->parser));
11346 }
11347 }
11348
11349 return error;
11350}
11351
11356 VALUE
11357pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
11358{
11359 VALUE error = pm_load_file(result, filepath, false);
11360 if (NIL_P(error)) {
11361 error = pm_parse_file(result, filepath, script_lines);
11362 }
11363
11364 return error;
11365}
11366
11373 VALUE
11374pm_parse_string(pm_parse_result_t *result, VALUE source, VALUE filepath, VALUE *script_lines)
11375{
11376 rb_encoding *encoding = rb_enc_get(source);
11377 if (!rb_enc_asciicompat(encoding)) {
11378 return rb_exc_new_cstr(rb_eArgError, "invalid source encoding");
11379 }
11380
11381 pm_options_frozen_string_literal_init(&result->options);
11382 pm_string_constant_init(&result->input, RSTRING_PTR(source), RSTRING_LEN(source));
11383 pm_options_encoding_set(&result->options, rb_enc_name(encoding));
11384
11385 result->node.filepath_encoding = rb_enc_get(filepath);
11386 pm_options_filepath_set(&result->options, RSTRING_PTR(filepath));
11387 RB_GC_GUARD(filepath);
11388
11389 pm_parser_init(&result->parser, pm_string_source(&result->input), pm_string_length(&result->input), &result->options);
11390 pm_node_t *node = pm_parse(&result->parser);
11391
11392 return pm_parse_process(result, node, script_lines);
11393}
11394
11398static char *
11399pm_parse_stdin_fgets(char *string, int size, void *stream)
11400{
11401 RUBY_ASSERT(size > 0);
11402
11403 VALUE line = rb_funcall((VALUE) stream, rb_intern("gets"), 1, INT2FIX(size - 1));
11404 if (NIL_P(line)) {
11405 return NULL;
11406 }
11407
11408 const char *cstr = RSTRING_PTR(line);
11409 long length = RSTRING_LEN(line);
11410
11411 memcpy(string, cstr, length);
11412 string[length] = '\0';
11413
11414 return string;
11415}
11416
11417// We need access to this function when we're done parsing stdin.
11418void rb_reset_argf_lineno(long n);
11419
11425 VALUE
11426pm_parse_stdin(pm_parse_result_t *result)
11427{
11428 pm_options_frozen_string_literal_init(&result->options);
11429
11430 pm_buffer_t buffer;
11431 pm_node_t *node = pm_parse_stream(&result->parser, &buffer, (void *) rb_stdin, pm_parse_stdin_fgets, &result->options);
11432
11433 // Copy the allocated buffer contents into the input string so that it gets
11434 // freed. At this point we've handed over ownership, so we don't need to
11435 // free the buffer itself.
11436 pm_string_owned_init(&result->input, (uint8_t *) pm_buffer_value(&buffer), pm_buffer_length(&buffer));
11437
11438 // When we're done parsing, we reset $. because we don't want the fact that
11439 // we went through an IO object to be visible to the user.
11440 rb_reset_argf_lineno(0);
11441
11442 return pm_parse_process(result, node, NULL);
11443}
11444
11445#undef NEW_ISEQ
11446#define NEW_ISEQ OLD_ISEQ
11447
11448#undef NEW_CHILD_ISEQ
11449#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_block_parameter_node_t
struct pm_block_parameter_node pm_block_parameter_node_t
BlockParameterNode.
pm_call_target_node_t
struct pm_call_target_node pm_call_target_node_t
CallTargetNode.
pm_else_node_t
struct pm_else_node pm_else_node_t
ElseNode.
pm_assoc_node_t
struct pm_assoc_node pm_assoc_node_t
AssocNode.
pm_undef_node_t
struct pm_undef_node pm_undef_node_t
UndefNode.
pm_class_variable_and_write_node_t
struct pm_class_variable_and_write_node pm_class_variable_and_write_node_t
ClassVariableAndWriteNode.
pm_index_and_write_node_t
struct pm_index_and_write_node pm_index_and_write_node_t
IndexAndWriteNode.
pm_index_target_node_t
struct pm_index_target_node pm_index_target_node_t
IndexTargetNode.
pm_local_variable_target_node_t
struct pm_local_variable_target_node pm_local_variable_target_node_t
LocalVariableTargetNode.
pm_constant_path_or_write_node_t
struct pm_constant_path_or_write_node pm_constant_path_or_write_node_t
ConstantPathOrWriteNode.
pm_embedded_statements_node_t
struct pm_embedded_statements_node pm_embedded_statements_node_t
EmbeddedStatementsNode.
pm_block_node_t
struct pm_block_node pm_block_node_t
BlockNode.
pm_hash_pattern_node_t
struct pm_hash_pattern_node pm_hash_pattern_node_t
HashPatternNode.
pm_optional_parameter_node_t
struct pm_optional_parameter_node pm_optional_parameter_node_t
OptionalParameterNode.
pm_x_string_node_t
struct pm_x_string_node pm_x_string_node_t
XStringNode.
pm_forwarding_super_node_t
struct pm_forwarding_super_node pm_forwarding_super_node_t
ForwardingSuperNode.
pm_numbered_reference_read_node_t
struct pm_numbered_reference_read_node pm_numbered_reference_read_node_t
NumberedReferenceReadNode.
pm_embedded_variable_node_t
struct pm_embedded_variable_node pm_embedded_variable_node_t
EmbeddedVariableNode.
pm_class_variable_write_node_t
struct pm_class_variable_write_node pm_class_variable_write_node_t
ClassVariableWriteNode.
pm_interpolated_string_node_t
struct pm_interpolated_string_node pm_interpolated_string_node_t
InterpolatedStringNode.
pm_class_variable_or_write_node_t
struct pm_class_variable_or_write_node pm_class_variable_or_write_node_t
ClassVariableOrWriteNode.
pm_optional_keyword_parameter_node_t
struct pm_optional_keyword_parameter_node pm_optional_keyword_parameter_node_t
OptionalKeywordParameterNode.
pm_call_or_write_node_t
struct pm_call_or_write_node pm_call_or_write_node_t
CallOrWriteNode.
pm_call_node_t
struct pm_call_node pm_call_node_t
CallNode.
pm_class_variable_read_node_t
struct pm_class_variable_read_node pm_class_variable_read_node_t
ClassVariableReadNode.
pm_match_required_node_t
struct pm_match_required_node pm_match_required_node_t
MatchRequiredNode.
pm_shareable_constant_node_t
struct pm_shareable_constant_node pm_shareable_constant_node_t
ShareableConstantNode.
pm_constant_and_write_node_t
struct pm_constant_and_write_node pm_constant_and_write_node_t
ConstantAndWriteNode.
PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE
@ PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE
mutable by virtue of a frozen_string_literal: false comment or --disable-frozen-string-literal; only ...
Definition ast.h:7822
PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN
@ PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN
frozen by virtue of a frozen_string_literal: true comment or --enable-frozen-string-literal; only for...
Definition ast.h:7819
pm_constant_path_operator_write_node_t
struct pm_constant_path_operator_write_node pm_constant_path_operator_write_node_t
ConstantPathOperatorWriteNode.
PM_RANGE_FLAGS_EXCLUDE_END
@ PM_RANGE_FLAGS_EXCLUDE_END
... operator
Definition ast.h:7854
pm_local_variable_or_write_node_t
struct pm_local_variable_or_write_node pm_local_variable_or_write_node_t
LocalVariableOrWriteNode.
pm_local_variable_read_node_t
struct pm_local_variable_read_node pm_local_variable_read_node_t
LocalVariableReadNode.
pm_global_variable_and_write_node_t
struct pm_global_variable_and_write_node pm_global_variable_and_write_node_t
GlobalVariableAndWriteNode.
pm_arguments_node_t
struct pm_arguments_node pm_arguments_node_t
ArgumentsNode.
pm_node_type
pm_node_type
This enum represents every type of node in the Ruby syntax tree.
Definition ast.h:572
PM_DEFINED_NODE
@ PM_DEFINED_NODE
DefinedNode.
Definition ast.h:709
PM_PRE_EXECUTION_NODE
@ PM_PRE_EXECUTION_NODE
PreExecutionNode.
Definition ast.h:931
PM_RETRY_NODE
@ PM_RETRY_NODE
RetryNode.
Definition ast.h:964
PM_REDO_NODE
@ PM_REDO_NODE
RedoNode.
Definition ast.h:943
PM_CONSTANT_PATH_WRITE_NODE
@ PM_CONSTANT_PATH_WRITE_NODE
ConstantPathWriteNode.
Definition ast.h:694
PM_INDEX_AND_WRITE_NODE
@ PM_INDEX_AND_WRITE_NODE
IndexAndWriteNode.
Definition ast.h:787
PM_SOURCE_LINE_NODE
@ PM_SOURCE_LINE_NODE
SourceLineNode.
Definition ast.h:985
PM_UNLESS_NODE
@ PM_UNLESS_NODE
UnlessNode.
Definition ast.h:1009
PM_EMBEDDED_VARIABLE_NODE
@ PM_EMBEDDED_VARIABLE_NODE
EmbeddedVariableNode.
Definition ast.h:718
PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE
@ PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE
GlobalVariableOperatorWriteNode.
Definition ast.h:751
PM_CALL_NODE
@ PM_CALL_NODE
CallNode.
Definition ast.h:628
PM_NIL_NODE
@ PM_NIL_NODE
NilNode.
Definition ast.h:895
PM_GLOBAL_VARIABLE_READ_NODE
@ PM_GLOBAL_VARIABLE_READ_NODE
GlobalVariableReadNode.
Definition ast.h:757
PM_RATIONAL_NODE
@ PM_RATIONAL_NODE
RationalNode.
Definition ast.h:940
PM_YIELD_NODE
@ PM_YIELD_NODE
YieldNode.
Definition ast.h:1024
PM_LOCAL_VARIABLE_AND_WRITE_NODE
@ PM_LOCAL_VARIABLE_AND_WRITE_NODE
LocalVariableAndWriteNode.
Definition ast.h:850
PM_CONSTANT_AND_WRITE_NODE
@ PM_CONSTANT_AND_WRITE_NODE
ConstantAndWriteNode.
Definition ast.h:670
PM_CLASS_NODE
@ PM_CLASS_NODE
ClassNode.
Definition ast.h:649
PM_FIND_PATTERN_NODE
@ PM_FIND_PATTERN_NODE
FindPatternNode.
Definition ast.h:727
PM_CALL_OPERATOR_WRITE_NODE
@ PM_CALL_OPERATOR_WRITE_NODE
CallOperatorWriteNode.
Definition ast.h:631
PM_MATCH_WRITE_NODE
@ PM_MATCH_WRITE_NODE
MatchWriteNode.
Definition ast.h:877
PM_ARRAY_NODE
@ PM_ARRAY_NODE
ArrayNode.
Definition ast.h:589
PM_CONSTANT_PATH_TARGET_NODE
@ PM_CONSTANT_PATH_TARGET_NODE
ConstantPathTargetNode.
Definition ast.h:691
PM_PROGRAM_NODE
@ PM_PROGRAM_NODE
ProgramNode.
Definition ast.h:934
PM_OR_NODE
@ PM_OR_NODE
OrNode.
Definition ast.h:913
PM_MULTI_WRITE_NODE
@ PM_MULTI_WRITE_NODE
MultiWriteNode.
Definition ast.h:889
PM_IF_NODE
@ PM_IF_NODE
IfNode.
Definition ast.h:772
PM_IMPLICIT_NODE
@ PM_IMPLICIT_NODE
ImplicitNode.
Definition ast.h:778
PM_ARGUMENTS_NODE
@ PM_ARGUMENTS_NODE
ArgumentsNode.
Definition ast.h:586
PM_FORWARDING_SUPER_NODE
@ PM_FORWARDING_SUPER_NODE
ForwardingSuperNode.
Definition ast.h:745
PM_WHILE_NODE
@ PM_WHILE_NODE
WhileNode.
Definition ast.h:1018
PM_INTERPOLATED_STRING_NODE
@ PM_INTERPOLATED_STRING_NODE
InterpolatedStringNode.
Definition ast.h:826
PM_FALSE_NODE
@ PM_FALSE_NODE
FalseNode.
Definition ast.h:724
PM_FORWARDING_PARAMETER_NODE
@ PM_FORWARDING_PARAMETER_NODE
ForwardingParameterNode.
Definition ast.h:742
PM_BLOCK_LOCAL_VARIABLE_NODE
@ PM_BLOCK_LOCAL_VARIABLE_NODE
BlockLocalVariableNode.
Definition ast.h:610
PM_HASH_NODE
@ PM_HASH_NODE
HashNode.
Definition ast.h:766
PM_UNTIL_NODE
@ PM_UNTIL_NODE
UntilNode.
Definition ast.h:1012
PM_MATCH_PREDICATE_NODE
@ PM_MATCH_PREDICATE_NODE
MatchPredicateNode.
Definition ast.h:871
PM_X_STRING_NODE
@ PM_X_STRING_NODE
XStringNode.
Definition ast.h:1021
PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE
@ PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE
LocalVariableOperatorWriteNode.
Definition ast.h:853
PM_LOCAL_VARIABLE_OR_WRITE_NODE
@ PM_LOCAL_VARIABLE_OR_WRITE_NODE
LocalVariableOrWriteNode.
Definition ast.h:856
PM_INSTANCE_VARIABLE_AND_WRITE_NODE
@ PM_INSTANCE_VARIABLE_AND_WRITE_NODE
InstanceVariableAndWriteNode.
Definition ast.h:799
PM_GLOBAL_VARIABLE_TARGET_NODE
@ PM_GLOBAL_VARIABLE_TARGET_NODE
GlobalVariableTargetNode.
Definition ast.h:760
PM_AND_NODE
@ PM_AND_NODE
AndNode.
Definition ast.h:583
PM_CONSTANT_TARGET_NODE
@ PM_CONSTANT_TARGET_NODE
ConstantTargetNode.
Definition ast.h:700
PM_IT_LOCAL_VARIABLE_READ_NODE
@ PM_IT_LOCAL_VARIABLE_READ_NODE
ItLocalVariableReadNode.
Definition ast.h:835
PM_CONSTANT_PATH_AND_WRITE_NODE
@ PM_CONSTANT_PATH_AND_WRITE_NODE
ConstantPathAndWriteNode.
Definition ast.h:679
PM_IN_NODE
@ PM_IN_NODE
InNode.
Definition ast.h:784
PM_BLOCK_PARAMETER_NODE
@ PM_BLOCK_PARAMETER_NODE
BlockParameterNode.
Definition ast.h:616
PM_CAPTURE_PATTERN_NODE
@ PM_CAPTURE_PATTERN_NODE
CapturePatternNode.
Definition ast.h:640
PM_SOURCE_FILE_NODE
@ PM_SOURCE_FILE_NODE
SourceFileNode.
Definition ast.h:982
PM_NO_KEYWORDS_PARAMETER_NODE
@ PM_NO_KEYWORDS_PARAMETER_NODE
NoKeywordsParameterNode.
Definition ast.h:898
PM_CONSTANT_PATH_OPERATOR_WRITE_NODE
@ PM_CONSTANT_PATH_OPERATOR_WRITE_NODE
ConstantPathOperatorWriteNode.
Definition ast.h:685
PM_MULTI_TARGET_NODE
@ PM_MULTI_TARGET_NODE
MultiTargetNode.
Definition ast.h:886
PM_SPLAT_NODE
@ PM_SPLAT_NODE
SplatNode.
Definition ast.h:988
PM_LAMBDA_NODE
@ PM_LAMBDA_NODE
LambdaNode.
Definition ast.h:847
PM_CLASS_VARIABLE_READ_NODE
@ PM_CLASS_VARIABLE_READ_NODE
ClassVariableReadNode.
Definition ast.h:661
PM_REQUIRED_KEYWORD_PARAMETER_NODE
@ PM_REQUIRED_KEYWORD_PARAMETER_NODE
RequiredKeywordParameterNode.
Definition ast.h:949
PM_CALL_TARGET_NODE
@ PM_CALL_TARGET_NODE
CallTargetNode.
Definition ast.h:637
PM_ELSE_NODE
@ PM_ELSE_NODE
ElseNode.
Definition ast.h:712
PM_INTERPOLATED_MATCH_LAST_LINE_NODE
@ PM_INTERPOLATED_MATCH_LAST_LINE_NODE
InterpolatedMatchLastLineNode.
Definition ast.h:820
PM_WHEN_NODE
@ PM_WHEN_NODE
WhenNode.
Definition ast.h:1015
PM_NUMBERED_PARAMETERS_NODE
@ PM_NUMBERED_PARAMETERS_NODE
NumberedParametersNode.
Definition ast.h:901
PM_SYMBOL_NODE
@ PM_SYMBOL_NODE
SymbolNode.
Definition ast.h:1000
PM_RESCUE_MODIFIER_NODE
@ PM_RESCUE_MODIFIER_NODE
RescueModifierNode.
Definition ast.h:955
PM_ALIAS_METHOD_NODE
@ PM_ALIAS_METHOD_NODE
AliasMethodNode.
Definition ast.h:577
PM_MATCH_REQUIRED_NODE
@ PM_MATCH_REQUIRED_NODE
MatchRequiredNode.
Definition ast.h:874
PM_FORWARDING_ARGUMENTS_NODE
@ PM_FORWARDING_ARGUMENTS_NODE
ForwardingArgumentsNode.
Definition ast.h:739
PM_BACK_REFERENCE_READ_NODE
@ PM_BACK_REFERENCE_READ_NODE
BackReferenceReadNode.
Definition ast.h:601
PM_SCOPE_NODE
@ PM_SCOPE_NODE
A special kind of node used for compilation.
Definition ast.h:1027
PM_BLOCK_ARGUMENT_NODE
@ PM_BLOCK_ARGUMENT_NODE
BlockArgumentNode.
Definition ast.h:607
PM_MISSING_NODE
@ PM_MISSING_NODE
MissingNode.
Definition ast.h:880
PM_SELF_NODE
@ PM_SELF_NODE
SelfNode.
Definition ast.h:970
PM_IMPLICIT_REST_NODE
@ PM_IMPLICIT_REST_NODE
ImplicitRestNode.
Definition ast.h:781
PM_TRUE_NODE
@ PM_TRUE_NODE
TrueNode.
Definition ast.h:1003
PM_ASSOC_SPLAT_NODE
@ PM_ASSOC_SPLAT_NODE
AssocSplatNode.
Definition ast.h:598
PM_CLASS_VARIABLE_AND_WRITE_NODE
@ PM_CLASS_VARIABLE_AND_WRITE_NODE
ClassVariableAndWriteNode.
Definition ast.h:652
PM_RANGE_NODE
@ PM_RANGE_NODE
RangeNode.
Definition ast.h:937
PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE
@ PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE
InstanceVariableOperatorWriteNode.
Definition ast.h:802
PM_LOCAL_VARIABLE_READ_NODE
@ PM_LOCAL_VARIABLE_READ_NODE
LocalVariableReadNode.
Definition ast.h:859
PM_SHAREABLE_CONSTANT_NODE
@ PM_SHAREABLE_CONSTANT_NODE
ShareableConstantNode.
Definition ast.h:973
PM_NEXT_NODE
@ PM_NEXT_NODE
NextNode.
Definition ast.h:892
PM_INSTANCE_VARIABLE_OR_WRITE_NODE
@ PM_INSTANCE_VARIABLE_OR_WRITE_NODE
InstanceVariableOrWriteNode.
Definition ast.h:805
PM_REGULAR_EXPRESSION_NODE
@ PM_REGULAR_EXPRESSION_NODE
RegularExpressionNode.
Definition ast.h:946
PM_CLASS_VARIABLE_OR_WRITE_NODE
@ PM_CLASS_VARIABLE_OR_WRITE_NODE
ClassVariableOrWriteNode.
Definition ast.h:658
PM_BLOCK_PARAMETERS_NODE
@ PM_BLOCK_PARAMETERS_NODE
BlockParametersNode.
Definition ast.h:619
PM_CONSTANT_WRITE_NODE
@ PM_CONSTANT_WRITE_NODE
ConstantWriteNode.
Definition ast.h:703
PM_HASH_PATTERN_NODE
@ PM_HASH_PATTERN_NODE
HashPatternNode.
Definition ast.h:769
PM_INDEX_OPERATOR_WRITE_NODE
@ PM_INDEX_OPERATOR_WRITE_NODE
IndexOperatorWriteNode.
Definition ast.h:790
PM_UNDEF_NODE
@ PM_UNDEF_NODE
UndefNode.
Definition ast.h:1006
PM_ALTERNATION_PATTERN_NODE
@ PM_ALTERNATION_PATTERN_NODE
AlternationPatternNode.
Definition ast.h:580
PM_ENSURE_NODE
@ PM_ENSURE_NODE
EnsureNode.
Definition ast.h:721
PM_LOCAL_VARIABLE_WRITE_NODE
@ PM_LOCAL_VARIABLE_WRITE_NODE
LocalVariableWriteNode.
Definition ast.h:865
PM_SINGLETON_CLASS_NODE
@ PM_SINGLETON_CLASS_NODE
SingletonClassNode.
Definition ast.h:976
PM_KEYWORD_HASH_NODE
@ PM_KEYWORD_HASH_NODE
KeywordHashNode.
Definition ast.h:841
PM_PARENTHESES_NODE
@ PM_PARENTHESES_NODE
ParenthesesNode.
Definition ast.h:919
PM_FOR_NODE
@ PM_FOR_NODE
ForNode.
Definition ast.h:736
PM_CLASS_VARIABLE_WRITE_NODE
@ PM_CLASS_VARIABLE_WRITE_NODE
ClassVariableWriteNode.
Definition ast.h:667
PM_POST_EXECUTION_NODE
@ PM_POST_EXECUTION_NODE
PostExecutionNode.
Definition ast.h:928
PM_CONSTANT_OPERATOR_WRITE_NODE
@ PM_CONSTANT_OPERATOR_WRITE_NODE
ConstantOperatorWriteNode.
Definition ast.h:673
PM_RETURN_NODE
@ PM_RETURN_NODE
ReturnNode.
Definition ast.h:967
PM_MODULE_NODE
@ PM_MODULE_NODE
ModuleNode.
Definition ast.h:883
PM_ARRAY_PATTERN_NODE
@ PM_ARRAY_PATTERN_NODE
ArrayPatternNode.
Definition ast.h:592
PM_SUPER_NODE
@ PM_SUPER_NODE
SuperNode.
Definition ast.h:997
PM_MATCH_LAST_LINE_NODE
@ PM_MATCH_LAST_LINE_NODE
MatchLastLineNode.
Definition ast.h:868
PM_CONSTANT_PATH_NODE
@ PM_CONSTANT_PATH_NODE
ConstantPathNode.
Definition ast.h:682
PM_INTERPOLATED_SYMBOL_NODE
@ PM_INTERPOLATED_SYMBOL_NODE
InterpolatedSymbolNode.
Definition ast.h:829
PM_CALL_AND_WRITE_NODE
@ PM_CALL_AND_WRITE_NODE
CallAndWriteNode.
Definition ast.h:625
PM_OPTIONAL_KEYWORD_PARAMETER_NODE
@ PM_OPTIONAL_KEYWORD_PARAMETER_NODE
OptionalKeywordParameterNode.
Definition ast.h:907
PM_CLASS_VARIABLE_TARGET_NODE
@ PM_CLASS_VARIABLE_TARGET_NODE
ClassVariableTargetNode.
Definition ast.h:664
PM_CASE_MATCH_NODE
@ PM_CASE_MATCH_NODE
CaseMatchNode.
Definition ast.h:643
PM_BREAK_NODE
@ PM_BREAK_NODE
BreakNode.
Definition ast.h:622
PM_CALL_OR_WRITE_NODE
@ PM_CALL_OR_WRITE_NODE
CallOrWriteNode.
Definition ast.h:634
PM_IMAGINARY_NODE
@ PM_IMAGINARY_NODE
ImaginaryNode.
Definition ast.h:775
PM_DEF_NODE
@ PM_DEF_NODE
DefNode.
Definition ast.h:706
PM_CONSTANT_READ_NODE
@ PM_CONSTANT_READ_NODE
ConstantReadNode.
Definition ast.h:697
PM_GLOBAL_VARIABLE_WRITE_NODE
@ PM_GLOBAL_VARIABLE_WRITE_NODE
GlobalVariableWriteNode.
Definition ast.h:763
PM_SOURCE_ENCODING_NODE
@ PM_SOURCE_ENCODING_NODE
SourceEncodingNode.
Definition ast.h:979
PM_BEGIN_NODE
@ PM_BEGIN_NODE
BeginNode.
Definition ast.h:604
PM_INTERPOLATED_X_STRING_NODE
@ PM_INTERPOLATED_X_STRING_NODE
InterpolatedXStringNode.
Definition ast.h:832
PM_INSTANCE_VARIABLE_READ_NODE
@ PM_INSTANCE_VARIABLE_READ_NODE
InstanceVariableReadNode.
Definition ast.h:808
PM_FLIP_FLOP_NODE
@ PM_FLIP_FLOP_NODE
FlipFlopNode.
Definition ast.h:730
PM_PINNED_VARIABLE_NODE
@ PM_PINNED_VARIABLE_NODE
PinnedVariableNode.
Definition ast.h:925
PM_REQUIRED_PARAMETER_NODE
@ PM_REQUIRED_PARAMETER_NODE
RequiredParameterNode.
Definition ast.h:952
PM_INSTANCE_VARIABLE_WRITE_NODE
@ PM_INSTANCE_VARIABLE_WRITE_NODE
InstanceVariableWriteNode.
Definition ast.h:814
PM_INSTANCE_VARIABLE_TARGET_NODE
@ PM_INSTANCE_VARIABLE_TARGET_NODE
InstanceVariableTargetNode.
Definition ast.h:811
PM_GLOBAL_VARIABLE_AND_WRITE_NODE
@ PM_GLOBAL_VARIABLE_AND_WRITE_NODE
GlobalVariableAndWriteNode.
Definition ast.h:748
PM_CASE_NODE
@ PM_CASE_NODE
CaseNode.
Definition ast.h:646
PM_RESCUE_NODE
@ PM_RESCUE_NODE
RescueNode.
Definition ast.h:958
PM_FLOAT_NODE
@ PM_FLOAT_NODE
FloatNode.
Definition ast.h:733
PM_ASSOC_NODE
@ PM_ASSOC_NODE
AssocNode.
Definition ast.h:595
PM_IT_PARAMETERS_NODE
@ PM_IT_PARAMETERS_NODE
ItParametersNode.
Definition ast.h:838
PM_INTEGER_NODE
@ PM_INTEGER_NODE
IntegerNode.
Definition ast.h:817
PM_LOCAL_VARIABLE_TARGET_NODE
@ PM_LOCAL_VARIABLE_TARGET_NODE
LocalVariableTargetNode.
Definition ast.h:862
PM_STRING_NODE
@ PM_STRING_NODE
StringNode.
Definition ast.h:994
PM_INDEX_OR_WRITE_NODE
@ PM_INDEX_OR_WRITE_NODE
IndexOrWriteNode.
Definition ast.h:793
PM_ALIAS_GLOBAL_VARIABLE_NODE
@ PM_ALIAS_GLOBAL_VARIABLE_NODE
AliasGlobalVariableNode.
Definition ast.h:574
PM_PARAMETERS_NODE
@ PM_PARAMETERS_NODE
ParametersNode.
Definition ast.h:916
PM_NUMBERED_REFERENCE_READ_NODE
@ PM_NUMBERED_REFERENCE_READ_NODE
NumberedReferenceReadNode.
Definition ast.h:904
PM_CONSTANT_PATH_OR_WRITE_NODE
@ PM_CONSTANT_PATH_OR_WRITE_NODE
ConstantPathOrWriteNode.
Definition ast.h:688
PM_GLOBAL_VARIABLE_OR_WRITE_NODE
@ PM_GLOBAL_VARIABLE_OR_WRITE_NODE
GlobalVariableOrWriteNode.
Definition ast.h:754
PM_CONSTANT_OR_WRITE_NODE
@ PM_CONSTANT_OR_WRITE_NODE
ConstantOrWriteNode.
Definition ast.h:676
PM_STATEMENTS_NODE
@ PM_STATEMENTS_NODE
StatementsNode.
Definition ast.h:991
PM_OPTIONAL_PARAMETER_NODE
@ PM_OPTIONAL_PARAMETER_NODE
OptionalParameterNode.
Definition ast.h:910
PM_PINNED_EXPRESSION_NODE
@ PM_PINNED_EXPRESSION_NODE
PinnedExpressionNode.
Definition ast.h:922
PM_BLOCK_NODE
@ PM_BLOCK_NODE
BlockNode.
Definition ast.h:613
PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE
@ PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE
ClassVariableOperatorWriteNode.
Definition ast.h:655
PM_REST_PARAMETER_NODE
@ PM_REST_PARAMETER_NODE
RestParameterNode.
Definition ast.h:961
PM_EMBEDDED_STATEMENTS_NODE
@ PM_EMBEDDED_STATEMENTS_NODE
EmbeddedStatementsNode.
Definition ast.h:715
PM_INTERPOLATED_REGULAR_EXPRESSION_NODE
@ PM_INTERPOLATED_REGULAR_EXPRESSION_NODE
InterpolatedRegularExpressionNode.
Definition ast.h:823
PM_INDEX_TARGET_NODE
@ PM_INDEX_TARGET_NODE
IndexTargetNode.
Definition ast.h:796
PM_KEYWORD_REST_PARAMETER_NODE
@ PM_KEYWORD_REST_PARAMETER_NODE
KeywordRestParameterNode.
Definition ast.h:844
pm_begin_node_t
struct pm_begin_node pm_begin_node_t
BeginNode.
pm_statements_node_t
struct pm_statements_node pm_statements_node_t
StatementsNode.
pm_instance_variable_write_node_t
struct pm_instance_variable_write_node pm_instance_variable_write_node_t
InstanceVariableWriteNode.
pm_keyword_hash_node_t
struct pm_keyword_hash_node pm_keyword_hash_node_t
KeywordHashNode.
pm_return_node_t
struct pm_return_node pm_return_node_t
ReturnNode.
PM_NODE_FLAG_NEWLINE
static const pm_node_flags_t PM_NODE_FLAG_NEWLINE
We store the flags enum in every node in the tree.
Definition ast.h:1046
PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING
@ PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING
internal bytes forced the encoding to UTF-8
Definition ast.h:7931
PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING
@ PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING
internal bytes forced the encoding to US-ASCII
Definition ast.h:7937
PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING
@ PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
Definition ast.h:7934
pm_constant_path_node_t
struct pm_constant_path_node pm_constant_path_node_t
ConstantPathNode.
pm_local_variable_write_node_t
struct pm_local_variable_write_node pm_local_variable_write_node_t
LocalVariableWriteNode.
PM_STRING_FLAGS_FROZEN
@ PM_STRING_FLAGS_FROZEN
frozen by virtue of a frozen_string_literal: true comment or --enable-frozen-string-literal
Definition ast.h:7920
PM_STRING_FLAGS_FORCED_BINARY_ENCODING
@ PM_STRING_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
Definition ast.h:7917
PM_STRING_FLAGS_MUTABLE
@ PM_STRING_FLAGS_MUTABLE
mutable by virtue of a frozen_string_literal: false comment or --disable-frozen-string-literal
Definition ast.h:7923
PM_STRING_FLAGS_FORCED_UTF8_ENCODING
@ PM_STRING_FLAGS_FORCED_UTF8_ENCODING
internal bytes forced the encoding to UTF-8
Definition ast.h:7914
pm_implicit_node_t
struct pm_implicit_node pm_implicit_node_t
ImplicitNode.
pm_yield_node_t
struct pm_yield_node pm_yield_node_t
YieldNode.
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT
if the arguments contain a splat
Definition ast.h:7755
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING
if the arguments contain forwarding
Definition ast.h:7746
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT
if the arguments contain a keyword splat
Definition ast.h:7752
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS
if the arguments contain multiple splats
Definition ast.h:7758
pm_local_variable_and_write_node_t
struct pm_local_variable_and_write_node pm_local_variable_and_write_node_t
LocalVariableAndWriteNode.
pm_parameters_node_t
struct pm_parameters_node pm_parameters_node_t
ParametersNode.
pm_lambda_node_t
struct pm_lambda_node pm_lambda_node_t
LambdaNode.
PM_NODE_FLAG_P
#define PM_NODE_FLAG_P(node, flag)
Return true if the given flag is set on the given node.
Definition ast.h:1063
pm_module_node_t
struct pm_module_node pm_module_node_t
ModuleNode.
pm_case_node_t
struct pm_case_node pm_case_node_t
CaseNode.
pm_in_node_t
struct pm_in_node pm_in_node_t
InNode.
pm_if_node_t
struct pm_if_node pm_if_node_t
IfNode.
pm_constant_path_write_node_t
struct pm_constant_path_write_node pm_constant_path_write_node_t
ConstantPathWriteNode.
pm_pre_execution_node_t
struct pm_pre_execution_node pm_pre_execution_node_t
PreExecutionNode.
pm_rescue_modifier_node_t
struct pm_rescue_modifier_node pm_rescue_modifier_node_t
RescueModifierNode.
pm_splat_node_t
struct pm_splat_node pm_splat_node_t
SplatNode.
pm_match_write_node_t
struct pm_match_write_node pm_match_write_node_t
MatchWriteNode.
pm_multi_write_node_t
struct pm_multi_write_node pm_multi_write_node_t
MultiWriteNode.
pm_local_variable_operator_write_node_t
struct pm_local_variable_operator_write_node pm_local_variable_operator_write_node_t
LocalVariableOperatorWriteNode.
pm_block_argument_node_t
struct pm_block_argument_node pm_block_argument_node_t
BlockArgumentNode.
pm_interpolated_x_string_node_t
struct pm_interpolated_x_string_node pm_interpolated_x_string_node_t
InterpolatedXStringNode.
pm_constant_write_node_t
struct pm_constant_write_node pm_constant_write_node_t
ConstantWriteNode.
pm_flip_flop_node_t
struct pm_flip_flop_node pm_flip_flop_node_t
FlipFlopNode.
pm_required_keyword_parameter_node_t
struct pm_required_keyword_parameter_node pm_required_keyword_parameter_node_t
RequiredKeywordParameterNode.
PM_NODE_TYPE_P
#define PM_NODE_TYPE_P(node, type)
Return true if the type of the given node matches the given type.
Definition ast.h:1058
PM_NODE_TYPE
#define PM_NODE_TYPE(node)
Cast the type to an enum to allow the compiler to provide exhaustiveness checking.
Definition ast.h:1053
pm_alias_global_variable_node_t
struct pm_alias_global_variable_node pm_alias_global_variable_node_t
AliasGlobalVariableNode.
pm_post_execution_node_t
struct pm_post_execution_node pm_post_execution_node_t
PostExecutionNode.
pm_alias_method_node_t
struct pm_alias_method_node pm_alias_method_node_t
AliasMethodNode.
pm_keyword_rest_parameter_node_t
struct pm_keyword_rest_parameter_node pm_keyword_rest_parameter_node_t
KeywordRestParameterNode.
pm_global_variable_read_node_t
struct pm_global_variable_read_node pm_global_variable_read_node_t
GlobalVariableReadNode.
pm_back_reference_read_node_t
struct pm_back_reference_read_node pm_back_reference_read_node_t
BackReferenceReadNode.
pm_match_last_line_node_t
struct pm_match_last_line_node pm_match_last_line_node_t
MatchLastLineNode.
pm_hash_node_t
struct pm_hash_node pm_hash_node_t
HashNode.
pm_block_local_variable_node_t
struct pm_block_local_variable_node pm_block_local_variable_node_t
BlockLocalVariableNode.
pm_multi_target_node_t
struct pm_multi_target_node pm_multi_target_node_t
MultiTargetNode.
pm_rational_node_t
struct pm_rational_node pm_rational_node_t
RationalNode.
pm_class_node_t
struct pm_class_node pm_class_node_t
ClassNode.
pm_pinned_expression_node_t
struct pm_pinned_expression_node pm_pinned_expression_node_t
PinnedExpressionNode.
pm_constant_operator_write_node_t
struct pm_constant_operator_write_node pm_constant_operator_write_node_t
ConstantOperatorWriteNode.
pm_ensure_node_t
struct pm_ensure_node pm_ensure_node_t
EnsureNode.
pm_index_or_write_node_t
struct pm_index_or_write_node pm_index_or_write_node_t
IndexOrWriteNode.
pm_constant_or_write_node_t
struct pm_constant_or_write_node pm_constant_or_write_node_t
ConstantOrWriteNode.
pm_index_operator_write_node_t
struct pm_index_operator_write_node pm_index_operator_write_node_t
IndexOperatorWriteNode.
pm_when_node_t
struct pm_when_node pm_when_node_t
WhenNode.
pm_super_node_t
struct pm_super_node pm_super_node_t
SuperNode.
pm_range_node_t
struct pm_range_node pm_range_node_t
RangeNode.
pm_and_node_t
struct pm_and_node pm_and_node_t
AndNode.
pm_constant_path_and_write_node_t
struct pm_constant_path_and_write_node pm_constant_path_and_write_node_t
ConstantPathAndWriteNode.
pm_rest_parameter_node_t
struct pm_rest_parameter_node pm_rest_parameter_node_t
RestParameterNode.
pm_assoc_splat_node_t
struct pm_assoc_splat_node pm_assoc_splat_node_t
AssocSplatNode.
PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
@ PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
a call that ignores method visibility
Definition ast.h:7783
PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
@ PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
&.
Definition ast.h:7774
PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
@ PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
a call that is an attribute write, so the value being written should be returned
Definition ast.h:7780
PM_CALL_NODE_FLAGS_VARIABLE_CALL
@ PM_CALL_NODE_FLAGS_VARIABLE_CALL
a call that could have been a local variable
Definition ast.h:7777
pm_constant_read_node_t
struct pm_constant_read_node pm_constant_read_node_t
ConstantReadNode.
pm_match_predicate_node_t
struct pm_match_predicate_node pm_match_predicate_node_t
MatchPredicateNode.
pm_or_node_t
struct pm_or_node pm_or_node_t
OrNode.
pm_case_match_node_t
struct pm_case_match_node pm_case_match_node_t
CaseMatchNode.
pm_call_and_write_node_t
struct pm_call_and_write_node pm_call_and_write_node_t
CallAndWriteNode.
PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING
@ PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING
constant writes that should be modified with shareable constant value experimental everything
Definition ast.h:7903
PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL
@ PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL
constant writes that should be modified with shareable constant value literal
Definition ast.h:7900
PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY
@ PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY
constant writes that should be modified with shareable constant value experimental copy
Definition ast.h:7906
pm_until_node_t
struct pm_until_node pm_until_node_t
UntilNode.
pm_node_type_t
uint16_t pm_node_type_t
This is the type of node embedded in the node struct.
Definition ast.h:1034
pm_imaginary_node_t
struct pm_imaginary_node pm_imaginary_node_t
ImaginaryNode.
pm_array_pattern_node_t
struct pm_array_pattern_node pm_array_pattern_node_t
ArrayPatternNode.
PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS
@ PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS
a keyword hash which only has AssocNode elements all with symbol keys, which means the elements can b...
Definition ast.h:7830
pm_break_node_t
struct pm_break_node pm_break_node_t
BreakNode.
pm_integer_node_t
struct pm_integer_node pm_integer_node_t
IntegerNode.
pm_constant_path_target_node_t
struct pm_constant_path_target_node pm_constant_path_target_node_t
ConstantPathTargetNode.
pm_call_operator_write_node_t
struct pm_call_operator_write_node pm_call_operator_write_node_t
CallOperatorWriteNode.
pm_for_node_t
struct pm_for_node pm_for_node_t
ForNode.
pm_global_variable_target_node_t
struct pm_global_variable_target_node pm_global_variable_target_node_t
GlobalVariableTargetNode.
pm_node_list_t
struct pm_node_list pm_node_list_t
A list of nodes in the source, most often used for lists of children.
pm_required_parameter_node_t
struct pm_required_parameter_node pm_required_parameter_node_t
RequiredParameterNode.
pm_symbol_node_t
struct pm_symbol_node pm_symbol_node_t
SymbolNode.
pm_block_parameters_node_t
struct pm_block_parameters_node pm_block_parameters_node_t
BlockParametersNode.
pm_alternation_pattern_node_t
struct pm_alternation_pattern_node pm_alternation_pattern_node_t
AlternationPatternNode.
pm_parentheses_node_t
struct pm_parentheses_node pm_parentheses_node_t
ParenthesesNode.
PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING
@ PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
Definition ast.h:7889
PM_REGULAR_EXPRESSION_FLAGS_EUC_JP
@ PM_REGULAR_EXPRESSION_FLAGS_EUC_JP
e - forces the EUC-JP encoding
Definition ast.h:7874
PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE
@ PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE
i - ignores the case of characters when matching
Definition ast.h:7862
PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT
@ PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT
n - forces the ASCII-8BIT encoding
Definition ast.h:7877
PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE
@ PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE
m - allows $ to match the end of lines within strings
Definition ast.h:7868
PM_REGULAR_EXPRESSION_FLAGS_EXTENDED
@ PM_REGULAR_EXPRESSION_FLAGS_EXTENDED
x - ignores whitespace and allows comments in regular expressions
Definition ast.h:7865
PM_REGULAR_EXPRESSION_FLAGS_ONCE
@ PM_REGULAR_EXPRESSION_FLAGS_ONCE
o - only interpolates values into the regular expression once
Definition ast.h:7871
PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J
@ PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J
s - forces the Windows-31J encoding
Definition ast.h:7880
PM_REGULAR_EXPRESSION_FLAGS_UTF_8
@ PM_REGULAR_EXPRESSION_FLAGS_UTF_8
u - forces the UTF-8 encoding
Definition ast.h:7883
pm_instance_variable_read_node_t
struct pm_instance_variable_read_node pm_instance_variable_read_node_t
InstanceVariableReadNode.
pm_constant_target_node_t
struct pm_constant_target_node pm_constant_target_node_t
ConstantTargetNode.
pm_node_t
struct pm_node pm_node_t
This is the base structure that represents a node in the syntax tree.
pm_defined_node_t
struct pm_defined_node pm_defined_node_t
DefinedNode.
pm_interpolated_symbol_node_t
struct pm_interpolated_symbol_node pm_interpolated_symbol_node_t
InterpolatedSymbolNode.
pm_class_variable_target_node_t
struct pm_class_variable_target_node pm_class_variable_target_node_t
ClassVariableTargetNode.
pm_def_node_t
struct pm_def_node pm_def_node_t
DefNode.
pm_singleton_class_node_t
struct pm_singleton_class_node pm_singleton_class_node_t
SingletonClassNode.
pm_node_flags_t
uint16_t pm_node_flags_t
These are the flags embedded in the node struct.
Definition ast.h:1040
pm_capture_pattern_node_t
struct pm_capture_pattern_node pm_capture_pattern_node_t
CapturePatternNode.
pm_source_file_node_t
struct pm_source_file_node pm_source_file_node_t
SourceFileNode.
pm_regular_expression_node_t
struct pm_regular_expression_node pm_regular_expression_node_t
RegularExpressionNode.
pm_global_variable_or_write_node_t
struct pm_global_variable_or_write_node pm_global_variable_or_write_node_t
GlobalVariableOrWriteNode.
pm_rescue_node_t
struct pm_rescue_node pm_rescue_node_t
RescueNode.
pm_array_node_t
struct pm_array_node pm_array_node_t
ArrayNode.
pm_while_node_t
struct pm_while_node pm_while_node_t
WhileNode.
pm_global_variable_write_node_t
struct pm_global_variable_write_node pm_global_variable_write_node_t
GlobalVariableWriteNode.
pm_instance_variable_or_write_node_t
struct pm_instance_variable_or_write_node pm_instance_variable_or_write_node_t
InstanceVariableOrWriteNode.
PM_PARAMETER_FLAGS_REPEATED_PARAMETER
@ PM_PARAMETER_FLAGS_REPEATED_PARAMETER
a parameter name that has been repeated in the method signature
Definition ast.h:7846
PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING
@ PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
Definition ast.h:7794
PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING
@ PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING
internal bytes forced the encoding to UTF-8
Definition ast.h:7791
pm_interpolated_match_last_line_node_t
struct pm_interpolated_match_last_line_node pm_interpolated_match_last_line_node_t
InterpolatedMatchLastLineNode.
pm_numbered_parameters_node_t
struct pm_numbered_parameters_node pm_numbered_parameters_node_t
NumberedParametersNode.
pm_class_variable_operator_write_node_t
struct pm_class_variable_operator_write_node pm_class_variable_operator_write_node_t
ClassVariableOperatorWriteNode.
pm_next_node_t
struct pm_next_node pm_next_node_t
NextNode.
pm_unless_node_t
struct pm_unless_node pm_unless_node_t
UnlessNode.
pm_interpolated_regular_expression_node_t
struct pm_interpolated_regular_expression_node pm_interpolated_regular_expression_node_t
InterpolatedRegularExpressionNode.
pm_instance_variable_target_node_t
struct pm_instance_variable_target_node pm_instance_variable_target_node_t
InstanceVariableTargetNode.
pm_string_node_t
struct pm_string_node pm_string_node_t
StringNode.
pm_float_node_t
struct pm_float_node pm_float_node_t
FloatNode.
pm_global_variable_operator_write_node_t
struct pm_global_variable_operator_write_node pm_global_variable_operator_write_node_t
GlobalVariableOperatorWriteNode.
pm_instance_variable_operator_write_node_t
struct pm_instance_variable_operator_write_node pm_instance_variable_operator_write_node_t
InstanceVariableOperatorWriteNode.
PM_LOOP_FLAGS_BEGIN_MODIFIER
@ PM_LOOP_FLAGS_BEGIN_MODIFIER
a loop after a begin statement, so the body is executed first before the condition
Definition ast.h:7838
pm_pinned_variable_node_t
struct pm_pinned_variable_node pm_pinned_variable_node_t
PinnedVariableNode.
pm_instance_variable_and_write_node_t
struct pm_instance_variable_and_write_node pm_instance_variable_and_write_node_t
InstanceVariableAndWriteNode.
pm_program_node_t
struct pm_program_node pm_program_node_t
ProgramNode.
pm_find_pattern_node_t
struct pm_find_pattern_node pm_find_pattern_node_t
FindPatternNode.
PM_WARNING_LEVEL_VERBOSE
@ PM_WARNING_LEVEL_VERBOSE
For warnings which should be emitted if $VERBOSE == true.
Definition diagnostic.h:408
PM_ERROR_LEVEL_ARGUMENT
@ PM_ERROR_LEVEL_ARGUMENT
For errors that should raise an argument error.
Definition diagnostic.h:394
PM_ERROR_LEVEL_LOAD
@ PM_ERROR_LEVEL_LOAD
For errors that should raise a load error.
Definition diagnostic.h:397
PM_ERROR_LEVEL_SYNTAX
@ PM_ERROR_LEVEL_SYNTAX
For errors that should raise a syntax error.
Definition diagnostic.h:391
RUBY_EVENT_END
#define RUBY_EVENT_END
Encountered an end of a class clause.
Definition event.h:40
RUBY_EVENT_B_RETURN
#define RUBY_EVENT_B_RETURN
Encountered a next statement.
Definition event.h:56
RUBY_EVENT_CLASS
#define RUBY_EVENT_CLASS
Encountered a new class.
Definition event.h:39
RUBY_EVENT_LINE
#define RUBY_EVENT_LINE
Encountered a new line.
Definition event.h:38
RUBY_EVENT_RETURN
#define RUBY_EVENT_RETURN
Encountered a return statement.
Definition event.h:42
RUBY_EVENT_B_CALL
#define RUBY_EVENT_B_CALL
Encountered an yield statement.
Definition event.h:55
RUBY_EVENT_CALL
#define RUBY_EVENT_CALL
A method, written in Ruby, is called.
Definition event.h:41
RUBY_EVENT_RESCUE
#define RUBY_EVENT_RESCUE
Encountered a rescue statement.
Definition event.h:61
rb_str_new2
#define rb_str_new2
Old name of rb_str_new_cstr.
Definition string.h:1675
ALLOCV
#define ALLOCV
Old name of RB_ALLOCV.
Definition memory.h:404
ALLOC
#define ALLOC
Old name of RB_ALLOC.
Definition memory.h:400
RFLOAT_VALUE
#define RFLOAT_VALUE
Old name of rb_float_value.
Definition double.h:28
T_STRING
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
xfree
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
Qundef
#define Qundef
Old name of RUBY_Qundef.
Definition special_consts.h:62
INT2FIX
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
rb_str_cat2
#define rb_str_cat2
Old name of rb_str_cat_cstr.
Definition string.h:1683
ID2SYM
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
OBJ_FREEZE
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
Definition fl_type.h:135
ULONG2NUM
#define ULONG2NUM
Old name of RB_ULONG2NUM.
Definition long.h:60
FIXABLE
#define FIXABLE
Old name of RB_FIXABLE.
Definition fixnum.h:25
xmalloc
#define xmalloc
Old name of ruby_xmalloc.
Definition xmalloc.h:53
LONG2FIX
#define LONG2FIX
Old name of RB_INT2FIX.
Definition long.h:49
ZALLOC_N
#define ZALLOC_N
Old name of RB_ZALLOC_N.
Definition memory.h:401
T_HASH
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
ALLOC_N
#define ALLOC_N
Old name of RB_ALLOC_N.
Definition memory.h:399
rb_exc_new3
#define rb_exc_new3
Old name of rb_exc_new_str.
Definition error.h:38
Qtrue
#define Qtrue
Old name of RUBY_Qtrue.
Definition special_consts.h:61
INT2NUM
#define INT2NUM
Old name of RB_INT2NUM.
Definition int.h:43
Qnil
#define Qnil
Old name of RUBY_Qnil.
Definition special_consts.h:60
Qfalse
#define Qfalse
Old name of RUBY_Qfalse.
Definition special_consts.h:59
T_ARRAY
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
NIL_P
#define NIL_P
Old name of RB_NIL_P.
Definition special_consts.h:55
DBL2NUM
#define DBL2NUM
Old name of rb_float_new.
Definition double.h:29
xcalloc
#define xcalloc
Old name of ruby_xcalloc.
Definition xmalloc.h:55
NUM2LONG
#define NUM2LONG
Old name of RB_NUM2LONG.
Definition long.h:51
UINT2NUM
#define UINT2NUM
Old name of RB_UINT2NUM.
Definition int.h:46
CONST_ID
#define CONST_ID
Old name of RUBY_CONST_ID.
Definition symbol.h:47
ruby_debug
#define ruby_debug
This variable controls whether the interpreter is in debug mode.
Definition error.h:486
rb_eNotImpError
VALUE rb_eNotImpError
NotImplementedError exception.
Definition error.c:1440
rb_eStandardError
VALUE rb_eStandardError
StandardError exception.
Definition error.c:1427
rb_eLoadError
VALUE rb_eLoadError
LoadError exception.
Definition error.c:1448
rb_eTypeError
VALUE rb_eTypeError
TypeError exception.
Definition error.c:1430
rb_eNoMatchingPatternError
VALUE rb_eNoMatchingPatternError
NoMatchingPatternError exception.
Definition error.c:1443
rb_warn
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:466
rb_exc_new
VALUE rb_exc_new(VALUE etype, const char *ptr, long len)
Creates an instance of the passed exception class.
Definition error.c:1468
rb_eNoMatchingPatternKeyError
VALUE rb_eNoMatchingPatternKeyError
NoMatchingPatternKeyError exception.
Definition error.c:1444
rb_exc_new_str
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
Definition error.c:1481
rb_eSyntaxError
VALUE rb_eSyntaxError
SyntaxError exception.
Definition error.c:1447
rb_syserr_new
VALUE rb_syserr_new(int n, const char *mesg)
Creates an exception object that represents the given C errno.
Definition error.c:3863
rb_cArray
VALUE rb_cArray
Array class.
Definition array.c:40
rb_obj_hide
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
Definition object.c:104
rb_stdin
VALUE rb_stdin
STDIN constant.
Definition io.c:201
rb_obj_freeze
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
Definition object.c:1260
RB_OBJ_WRITTEN
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
Definition gc.h:615
RB_OBJ_WRITE
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Definition gc.h:603
rb_enc_str_coderange
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
Definition string.c:904
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:12524
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:1102
rb_funcall
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
Definition vm_eval.c:1099
rb_io_fdopen
VALUE rb_io_fdopen(int fd, int flags, const char *path)
Creates an IO instance whose backend is the given file descriptor.
Definition io.c:9338
rb_range_new
VALUE rb_range_new(VALUE beg, VALUE end, int excl)
Creates a new Range.
Definition range.c:68
rb_rational_new
VALUE rb_rational_new(VALUE num, VALUE den)
Constructs a Rational, with reduction.
Definition rational.c:1974
rb_str_append
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
Definition string.c:3680
rb_str_tmp_new
VALUE rb_str_tmp_new(long len)
Allocates a "temporary" string.
Definition string.c:1675
rb_str_new
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
Definition string.h:1498
rb_exc_new_cstr
#define rb_exc_new_cstr(exc, str)
Identical to rb_exc_new(), except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1670
rb_str_buf_new_cstr
#define rb_str_buf_new_cstr(str)
Identical to rb_str_new_cstr, except done differently.
Definition string.h:1639
rb_str_concat
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
Definition string.c:3922
rb_str_freeze
VALUE rb_str_freeze(VALUE str)
This is the implementation of String#freeze.
Definition string.c:3180
rb_str_new_cstr
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1514
rb_ivar_set
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1951
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:3249
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:3571
rb_intern_const
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
Definition symbol.h:284
rb_id2sym
VALUE rb_id2sym(ID id)
Allocates an instance of rb_cSymbol that has the given id.
Definition symbol.c:951
rb_sym2str
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
Definition symbol.c:970
RUBY_IO_READABLE
@ RUBY_IO_READABLE
IO::READABLE
Definition io.h:82
rb_io_wait
VALUE rb_io_wait(VALUE io, VALUE events, VALUE timeout)
Blocks until the passed IO is ready for the passed events.
Definition io.c:1453
len
int len
Length of the buffer.
Definition io.h:8
rb_ractor_make_shareable
VALUE rb_ractor_make_shareable(VALUE obj)
Destructively transforms the passed object so that multiple Ractors can share it.
Definition ractor.c:3115
DECIMAL_SIZE_OF
#define DECIMAL_SIZE_OF(expr)
An approximation of decimal representation size.
Definition util.h:48
RB_INT2NUM
#define RB_INT2NUM
Just another name of rb_int2num_inline.
Definition int.h:37
RB_GC_GUARD
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
ruby::backward::cxxanyargs::type
VALUE type(ANYARGS)
ANYARGS-ed function type.
Definition cxxanyargs.hpp:56
pm_options_t
struct pm_options pm_options_t
The options that can be passed to the parser.
pm_parser_t
struct pm_parser pm_parser_t
The parser used to parse Ruby source.
Definition parser.h:267
pm_constant_id_t
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
Definition pm_constant_pool.h:31
pm_list_node_t
struct pm_list_node pm_list_node_t
This struct represents an abstract linked list that provides common functionality.
pm_string_init_result_t
pm_string_init_result_t
Represents the result of calling pm_string_mapped_init or pm_string_file_init.
Definition pm_string.h:105
PM_STRING_INIT_SUCCESS
@ PM_STRING_INIT_SUCCESS
Indicates that the string was successfully initialized.
Definition pm_string.h:107
PM_STRING_INIT_ERROR_GENERIC
@ PM_STRING_INIT_ERROR_GENERIC
Indicates a generic error from a string_*_init function, where the type of error should be read from ...
Definition pm_string.h:112
PM_STRING_INIT_ERROR_DIRECTORY
@ PM_STRING_INIT_ERROR_DIRECTORY
Indicates that the file that was attempted to be opened was a directory.
Definition pm_string.h:116
PM_ENCODING_US_ASCII_ENTRY
#define PM_ENCODING_US_ASCII_ENTRY
This is the US-ASCII encoding.
Definition encoding.h:252
PM_NODE_LIST_FOREACH
#define PM_NODE_LIST_FOREACH(list, index, node)
Loop through each node in the node list, writing each node to the given pm_node_t pointer.
Definition node.h:17
prism.h
The main header file for the prism parser.
RARRAY_LEN
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
RARRAY_AREF
#define RARRAY_AREF(a, i)
Definition rarray.h:403
RARRAY_CONST_PTR
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
Definition rarray.h:52
errno
#define errno
Ractor-aware version of errno.
Definition ruby.h:388
RTEST
#define RTEST
This is an old name of RB_TEST.
Definition special_consts.h:51
default_encoding
Definition encoding.c:1542
ensure_range
Definition compile.c:115
iseq_compile_data_ensure_node_stack
Definition compile.c:121
pm_alias_global_variable_node::old_name
struct pm_node * old_name
AliasGlobalVariableNode#old_name.
Definition ast.h:1130
pm_alias_global_variable_node::new_name
struct pm_node * new_name
AliasGlobalVariableNode#new_name.
Definition ast.h:1120
pm_alias_method_node::old_name
struct pm_node * old_name
AliasMethodNode#old_name.
Definition ast.h:1190
pm_alias_method_node::new_name
struct pm_node * new_name
AliasMethodNode#new_name.
Definition ast.h:1174
pm_alternation_pattern_node::left
struct pm_node * left
AlternationPatternNode#left.
Definition ast.h:1228
pm_alternation_pattern_node::right
struct pm_node * right
AlternationPatternNode#right.
Definition ast.h:1238
pm_and_node::left
struct pm_node * left
AndNode#left.
Definition ast.h:1279
pm_and_node::right
struct pm_node * right
AndNode#right.
Definition ast.h:1292
pm_arguments_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1326
pm_arguments_node::arguments
struct pm_node_list arguments
ArgumentsNode#arguments.
Definition ast.h:1337
pm_array_node::elements
struct pm_node_list elements
ArrayNode#elements.
Definition ast.h:1365
pm_array_pattern_node::requireds
struct pm_node_list requireds
ArrayPatternNode#requireds.
Definition ast.h:1434
pm_array_pattern_node::rest
struct pm_node * rest
ArrayPatternNode#rest.
Definition ast.h:1444
pm_array_pattern_node::constant
struct pm_node * constant
ArrayPatternNode#constant.
Definition ast.h:1424
pm_array_pattern_node::posts
struct pm_node_list posts
ArrayPatternNode#posts.
Definition ast.h:1454
pm_assoc_node::value
struct pm_node * value
AssocNode#value.
Definition ast.h:1521
pm_assoc_node::key
struct pm_node * key
AssocNode#key.
Definition ast.h:1508
pm_assoc_splat_node::value
struct pm_node * value
AssocSplatNode#value.
Definition ast.h:1559
pm_back_reference_read_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1586
pm_begin_node::ensure_clause
struct pm_ensure_node * ensure_clause
BeginNode#ensure_clause.
Definition ast.h:1668
pm_begin_node::rescue_clause
struct pm_rescue_node * rescue_clause
BeginNode#rescue_clause.
Definition ast.h:1648
pm_begin_node::statements
struct pm_statements_node * statements
BeginNode#statements.
Definition ast.h:1638
pm_begin_node::else_clause
struct pm_else_node * else_clause
BeginNode#else_clause.
Definition ast.h:1658
pm_block_argument_node::expression
struct pm_node * expression
BlockArgumentNode#expression.
Definition ast.h:1706
pm_block_node::parameters
struct pm_node * parameters
BlockNode#parameters.
Definition ast.h:1789
pm_block_node::body
struct pm_node * body
BlockNode#body.
Definition ast.h:1799
pm_block_node::locals
pm_constant_id_list_t locals
BlockNode#locals.
Definition ast.h:1775
pm_break_node::arguments
struct pm_arguments_node * arguments
BreakNode#arguments.
Definition ast.h:1979
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:2083
pm_call_and_write_node::read_name
pm_constant_id_t read_name
CallAndWriteNode#read_name.
Definition ast.h:2053
pm_call_and_write_node::write_name
pm_constant_id_t write_name
CallAndWriteNode#write_name.
Definition ast.h:2063
pm_call_and_write_node::receiver
struct pm_node * receiver
CallAndWriteNode#receiver.
Definition ast.h:2023
pm_call_node::closing_loc
pm_location_t closing_loc
CallNode#closing_loc.
Definition ast.h:2200
pm_call_node::receiver
struct pm_node * receiver
CallNode#receiver.
Definition ast.h:2138
pm_call_node::name
pm_constant_id_t name
CallNode::name.
Definition ast.h:2161
pm_call_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2121
pm_call_node::message_loc
pm_location_t message_loc
CallNode#message_loc.
Definition ast.h:2171
pm_call_node::arguments
struct pm_arguments_node * arguments
CallNode#arguments.
Definition ast.h:2190
pm_call_node::block
struct pm_node * block
CallNode#block.
Definition ast.h:2210
pm_call_operator_write_node::read_name
pm_constant_id_t read_name
CallOperatorWriteNode#read_name.
Definition ast.h:2274
pm_call_operator_write_node::binary_operator
pm_constant_id_t binary_operator
CallOperatorWriteNode#binary_operator.
Definition ast.h:2294
pm_call_operator_write_node::receiver
struct pm_node * receiver
CallOperatorWriteNode#receiver.
Definition ast.h:2244
pm_call_operator_write_node::write_name
pm_constant_id_t write_name
CallOperatorWriteNode#write_name.
Definition ast.h:2284
pm_call_operator_write_node::value
struct pm_node * value
CallOperatorWriteNode#value.
Definition ast.h:2314
pm_call_or_write_node::receiver
struct pm_node * receiver
CallOrWriteNode#receiver.
Definition ast.h:2348
pm_call_or_write_node::value
struct pm_node * value
CallOrWriteNode#value.
Definition ast.h:2408
pm_call_or_write_node::write_name
pm_constant_id_t write_name
CallOrWriteNode#write_name.
Definition ast.h:2388
pm_call_or_write_node::read_name
pm_constant_id_t read_name
CallOrWriteNode#read_name.
Definition ast.h:2378
pm_call_target_node::name
pm_constant_id_t name
CallTargetNode#name.
Definition ast.h:2470
pm_call_target_node::receiver
struct pm_node * receiver
CallTargetNode#receiver.
Definition ast.h:2450
pm_capture_pattern_node::target
struct pm_local_variable_target_node * target
CapturePatternNode#target.
Definition ast.h:2518
pm_capture_pattern_node::value
struct pm_node * value
CapturePatternNode#value.
Definition ast.h:2508
pm_case_match_node::conditions
struct pm_node_list conditions
CaseMatchNode#conditions.
Definition ast.h:2568
pm_case_match_node::else_clause
struct pm_else_node * else_clause
CaseMatchNode#else_clause.
Definition ast.h:2578
pm_case_match_node::predicate
struct pm_node * predicate
CaseMatchNode#predicate.
Definition ast.h:2558
pm_case_node::predicate
struct pm_node * predicate
CaseNode#predicate.
Definition ast.h:2628
pm_case_node::else_clause
struct pm_else_node * else_clause
CaseNode#else_clause.
Definition ast.h:2648
pm_case_node::conditions
struct pm_node_list conditions
CaseNode#conditions.
Definition ast.h:2638
pm_class_node::constant_path
struct pm_node * constant_path
ClassNode#constant_path.
Definition ast.h:2701
pm_class_node::locals
pm_constant_id_list_t locals
ClassNode#locals.
Definition ast.h:2691
pm_class_node::name
pm_constant_id_t name
ClassNode#name.
Definition ast.h:2726
pm_class_node::body
struct pm_node * body
ClassNode#body.
Definition ast.h:2716
pm_class_node::superclass
struct pm_node * superclass
ClassNode#superclass.
Definition ast.h:2711
pm_class_variable_and_write_node::value
struct pm_node * value
ClassVariableAndWriteNode#value.
Definition ast.h:2784
pm_class_variable_and_write_node::name
pm_constant_id_t name
ClassVariableAndWriteNode#name.
Definition ast.h:2754
pm_class_variable_operator_write_node::name
pm_constant_id_t name
ClassVariableOperatorWriteNode#name.
Definition ast.h:2807
pm_class_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ClassVariableOperatorWriteNode#binary_operator.
Definition ast.h:2827
pm_class_variable_operator_write_node::value
struct pm_node * value
ClassVariableOperatorWriteNode#value.
Definition ast.h:2822
pm_class_variable_or_write_node::name
pm_constant_id_t name
ClassVariableOrWriteNode#name.
Definition ast.h:2850
pm_class_variable_or_write_node::value
struct pm_node * value
ClassVariableOrWriteNode#value.
Definition ast.h:2865
pm_class_variable_read_node::name
pm_constant_id_t name
ClassVariableReadNode#name.
Definition ast.h:2894
pm_class_variable_target_node::name
pm_constant_id_t name
ClassVariableTargetNode#name.
Definition ast.h:2917
pm_class_variable_write_node::value
struct pm_node * value
ClassVariableWriteNode#value.
Definition ast.h:2969
pm_class_variable_write_node::name
pm_constant_id_t name
ClassVariableWriteNode#name.
Definition ast.h:2946
pm_constant_and_write_node::name_loc
pm_location_t name_loc
ConstantAndWriteNode#name_loc.
Definition ast.h:3007
pm_constant_and_write_node::name
pm_constant_id_t name
ConstantAndWriteNode#name.
Definition ast.h:3002
pm_constant_and_write_node::value
struct pm_node * value
ConstantAndWriteNode#value.
Definition ast.h:3017
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:3040
pm_constant_operator_write_node::name_loc
pm_location_t name_loc
ConstantOperatorWriteNode#name_loc.
Definition ast.h:3045
pm_constant_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantOperatorWriteNode#binary_operator.
Definition ast.h:3060
pm_constant_operator_write_node::value
struct pm_node * value
ConstantOperatorWriteNode#value.
Definition ast.h:3055
pm_constant_or_write_node::name_loc
pm_location_t name_loc
ConstantOrWriteNode#name_loc.
Definition ast.h:3088
pm_constant_or_write_node::name
pm_constant_id_t name
ConstantOrWriteNode#name.
Definition ast.h:3083
pm_constant_or_write_node::value
struct pm_node * value
ConstantOrWriteNode#value.
Definition ast.h:3098
pm_constant_path_and_write_node::target
struct pm_constant_path_node * target
ConstantPathAndWriteNode#target.
Definition ast.h:3121
pm_constant_path_and_write_node::value
struct pm_node * value
ConstantPathAndWriteNode#value.
Definition ast.h:3131
pm_constant_path_node::name
pm_constant_id_t name
ConstantPathNode#name.
Definition ast.h:3172
pm_constant_path_node::parent
struct pm_node * parent
ConstantPathNode#parent.
Definition ast.h:3165
pm_constant_path_operator_write_node::target
struct pm_constant_path_node * target
ConstantPathOperatorWriteNode#target.
Definition ast.h:3221
pm_constant_path_operator_write_node::value
struct pm_node * value
ConstantPathOperatorWriteNode#value.
Definition ast.h:3231
pm_constant_path_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantPathOperatorWriteNode#binary_operator.
Definition ast.h:3236
pm_constant_path_or_write_node::value
struct pm_node * value
ConstantPathOrWriteNode#value.
Definition ast.h:3269
pm_constant_path_or_write_node::target
struct pm_constant_path_node * target
ConstantPathOrWriteNode#target.
Definition ast.h:3259
pm_constant_path_target_node::parent
struct pm_node * parent
ConstantPathTargetNode#parent.
Definition ast.h:3292
pm_constant_path_target_node::name
pm_constant_id_t name
ConstantPathTargetNode#name.
Definition ast.h:3297
pm_constant_path_write_node::target
struct pm_constant_path_node * target
ConstantPathWriteNode#target.
Definition ast.h:3344
pm_constant_path_write_node::value
struct pm_node * value
ConstantPathWriteNode#value.
Definition ast.h:3364
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:3381
pm_constant_read_node::name
pm_constant_id_t name
ConstantReadNode#name.
Definition ast.h:3393
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:3416
pm_constant_write_node::value
struct pm_node * value
ConstantWriteNode#value.
Definition ast.h:3468
pm_constant_write_node::name
pm_constant_id_t name
ConstantWriteNode#name.
Definition ast.h:3445
pm_def_node::parameters
struct pm_parameters_node * parameters
DefNode#parameters.
Definition ast.h:3517
pm_def_node::name
pm_constant_id_t name
DefNode#name.
Definition ast.h:3502
pm_def_node::body
struct pm_node * body
DefNode#body.
Definition ast.h:3522
pm_def_node::receiver
struct pm_node * receiver
DefNode#receiver.
Definition ast.h:3512
pm_def_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3496
pm_def_node::locals
pm_constant_id_list_t locals
DefNode#locals.
Definition ast.h:3527
pm_defined_node::value
struct pm_node * value
DefinedNode#value.
Definition ast.h:3585
pm_diagnostic_t
This struct represents a diagnostic generated during parsing.
Definition diagnostic.h:359
pm_diagnostic_t::location
pm_location_t location
The location of the diagnostic in the source.
Definition diagnostic.h:364
pm_diagnostic_t::message
const char * message
The message associated with the diagnostic.
Definition diagnostic.h:370
pm_diagnostic_t::node
pm_list_node_t node
The embedded base node.
Definition diagnostic.h:361
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:383
pm_else_node::statements
struct pm_statements_node * statements
ElseNode#statements.
Definition ast.h:3623
pm_embedded_statements_node::statements
struct pm_statements_node * statements
EmbeddedStatementsNode#statements.
Definition ast.h:3656
pm_embedded_variable_node::variable
struct pm_node * variable
EmbeddedVariableNode#variable.
Definition ast.h:3689
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:3721
pm_find_pattern_node::constant
struct pm_node * constant
FindPatternNode#constant.
Definition ast.h:3773
pm_find_pattern_node::right
struct pm_node * right
FindPatternNode#right.
Definition ast.h:3788
pm_find_pattern_node::requireds
struct pm_node_list requireds
FindPatternNode#requireds.
Definition ast.h:3783
pm_find_pattern_node::left
struct pm_splat_node * left
FindPatternNode#left.
Definition ast.h:3778
pm_flip_flop_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3818
pm_flip_flop_node::left
struct pm_node * left
FlipFlopNode#left.
Definition ast.h:3824
pm_flip_flop_node::right
struct pm_node * right
FlipFlopNode#right.
Definition ast.h:3829
pm_float_node::value
double value
FloatNode#value.
Definition ast.h:3859
pm_for_node::statements
struct pm_statements_node * statements
ForNode#statements.
Definition ast.h:3909
pm_for_node::collection
struct pm_node * collection
ForNode#collection.
Definition ast.h:3897
pm_forwarding_super_node::block
struct pm_block_node * block
ForwardingSuperNode#block.
Definition ast.h:4011
pm_global_variable_and_write_node::value
struct pm_node * value
GlobalVariableAndWriteNode#value.
Definition ast.h:4049
pm_global_variable_and_write_node::name
pm_constant_id_t name
GlobalVariableAndWriteNode#name.
Definition ast.h:4034
pm_global_variable_operator_write_node::name
pm_constant_id_t name
GlobalVariableOperatorWriteNode#name.
Definition ast.h:4072
pm_global_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
GlobalVariableOperatorWriteNode#binary_operator.
Definition ast.h:4092
pm_global_variable_operator_write_node::value
struct pm_node * value
GlobalVariableOperatorWriteNode#value.
Definition ast.h:4087
pm_global_variable_or_write_node::name
pm_constant_id_t name
GlobalVariableOrWriteNode#name.
Definition ast.h:4115
pm_global_variable_or_write_node::value
struct pm_node * value
GlobalVariableOrWriteNode#value.
Definition ast.h:4130
pm_global_variable_read_node::name
pm_constant_id_t name
GlobalVariableReadNode#name.
Definition ast.h:4159
pm_global_variable_target_node::name
pm_constant_id_t name
GlobalVariableTargetNode#name.
Definition ast.h:4182
pm_global_variable_write_node::value
struct pm_node * value
GlobalVariableWriteNode#value.
Definition ast.h:4234
pm_global_variable_write_node::name
pm_constant_id_t name
GlobalVariableWriteNode#name.
Definition ast.h:4211
pm_hash_node::elements
struct pm_node_list elements
HashNode#elements.
Definition ast.h:4285
pm_hash_pattern_node::elements
struct pm_node_list elements
HashPatternNode#elements.
Definition ast.h:4326
pm_hash_pattern_node::rest
struct pm_node * rest
HashPatternNode#rest.
Definition ast.h:4331
pm_hash_pattern_node::constant
struct pm_node * constant
HashPatternNode#constant.
Definition ast.h:4321
pm_if_node::predicate
struct pm_node * predicate
IfNode#predicate.
Definition ast.h:4395
pm_if_node::statements
struct pm_statements_node * statements
IfNode#statements.
Definition ast.h:4422
pm_imaginary_node::numeric
struct pm_node * numeric
ImaginaryNode#numeric.
Definition ast.h:4476
pm_implicit_node::value
struct pm_node * value
ImplicitNode#value.
Definition ast.h:4505
pm_in_node::statements
struct pm_statements_node * statements
InNode#statements.
Definition ast.h:4560
pm_in_node::pattern
struct pm_node * pattern
InNode#pattern.
Definition ast.h:4555
pm_index_and_write_node::arguments
struct pm_arguments_node * arguments
IndexAndWriteNode#arguments.
Definition ast.h:4614
pm_index_and_write_node::receiver
struct pm_node * receiver
IndexAndWriteNode#receiver.
Definition ast.h:4599
pm_index_and_write_node::block
struct pm_block_argument_node * block
IndexAndWriteNode#block.
Definition ast.h:4624
pm_index_and_write_node::value
struct pm_node * value
IndexAndWriteNode#value.
Definition ast.h:4634
pm_index_operator_write_node::block
struct pm_block_argument_node * block
IndexOperatorWriteNode#block.
Definition ast.h:4688
pm_index_operator_write_node::value
struct pm_node * value
IndexOperatorWriteNode#value.
Definition ast.h:4703
pm_index_operator_write_node::arguments
struct pm_arguments_node * arguments
IndexOperatorWriteNode#arguments.
Definition ast.h:4678
pm_index_operator_write_node::binary_operator
pm_constant_id_t binary_operator
IndexOperatorWriteNode#binary_operator.
Definition ast.h:4693
pm_index_operator_write_node::receiver
struct pm_node * receiver
IndexOperatorWriteNode#receiver.
Definition ast.h:4663
pm_index_or_write_node::block
struct pm_block_argument_node * block
IndexOrWriteNode#block.
Definition ast.h:4757
pm_index_or_write_node::receiver
struct pm_node * receiver
IndexOrWriteNode#receiver.
Definition ast.h:4732
pm_index_or_write_node::value
struct pm_node * value
IndexOrWriteNode#value.
Definition ast.h:4767
pm_index_or_write_node::arguments
struct pm_arguments_node * arguments
IndexOrWriteNode#arguments.
Definition ast.h:4747
pm_index_target_node::receiver
struct pm_node * receiver
IndexTargetNode#receiver.
Definition ast.h:4804
pm_index_target_node::arguments
struct pm_arguments_node * arguments
IndexTargetNode#arguments.
Definition ast.h:4814
pm_index_target_node::block
struct pm_block_argument_node * block
IndexTargetNode#block.
Definition ast.h:4824
pm_instance_variable_and_write_node::value
struct pm_node * value
InstanceVariableAndWriteNode#value.
Definition ast.h:4862
pm_instance_variable_and_write_node::name
pm_constant_id_t name
InstanceVariableAndWriteNode#name.
Definition ast.h:4847
pm_instance_variable_operator_write_node::value
struct pm_node * value
InstanceVariableOperatorWriteNode#value.
Definition ast.h:4900
pm_instance_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
InstanceVariableOperatorWriteNode#binary_operator.
Definition ast.h:4905
pm_instance_variable_operator_write_node::name
pm_constant_id_t name
InstanceVariableOperatorWriteNode#name.
Definition ast.h:4885
pm_instance_variable_or_write_node::value
struct pm_node * value
InstanceVariableOrWriteNode#value.
Definition ast.h:4943
pm_instance_variable_or_write_node::name
pm_constant_id_t name
InstanceVariableOrWriteNode#name.
Definition ast.h:4928
pm_instance_variable_read_node::name
pm_constant_id_t name
InstanceVariableReadNode#name.
Definition ast.h:4972
pm_instance_variable_target_node::name
pm_constant_id_t name
InstanceVariableTargetNode#name.
Definition ast.h:4995
pm_instance_variable_write_node::name
pm_constant_id_t name
InstanceVariableWriteNode#name.
Definition ast.h:5024
pm_instance_variable_write_node::value
struct pm_node * value
InstanceVariableWriteNode#value.
Definition ast.h:5047
pm_integer_node::value
pm_integer_t value
IntegerNode#value.
Definition ast.h:5088
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:5212
pm_interpolated_symbol_node::parts
struct pm_node_list parts
InterpolatedSymbolNode#parts.
Definition ast.h:5245
pm_interpolated_x_string_node::parts
struct pm_node_list parts
InterpolatedXStringNode#parts.
Definition ast.h:5278
pm_keyword_hash_node::elements
struct pm_node_list elements
KeywordHashNode#elements.
Definition ast.h:5345
pm_lambda_node::body
struct pm_node * body
LambdaNode#body.
Definition ast.h:5430
pm_lambda_node::opening_loc
pm_location_t opening_loc
LambdaNode#opening_loc.
Definition ast.h:5415
pm_lambda_node::parameters
struct pm_node * parameters
LambdaNode#parameters.
Definition ast.h:5425
pm_lambda_node::operator_loc
pm_location_t operator_loc
LambdaNode#operator_loc.
Definition ast.h:5410
pm_lambda_node::locals
pm_constant_id_list_t locals
LambdaNode#locals.
Definition ast.h:5405
pm_line_column_t
A line and column in a string.
Definition pm_newline_list.h:45
pm_line_column_t::column
uint32_t column
The column number.
Definition pm_newline_list.h:50
pm_line_column_t::line
int32_t line
The line number.
Definition pm_newline_list.h:47
pm_list_node::next
struct pm_list_node * next
A pointer to the next node in the list.
Definition pm_list.h:48
pm_list_t
This represents the overall linked list.
Definition pm_list.h:55
pm_list_t::head
pm_list_node_t * head
A pointer to the head of the list.
Definition pm_list.h:60
pm_list_t::size
size_t size
The size of the list.
Definition pm_list.h:57
pm_local_table_insert_ctx
Definition prism_compile.c:4571
pm_local_variable_and_write_node::name
pm_constant_id_t name
LocalVariableAndWriteNode#name.
Definition ast.h:5468
pm_local_variable_and_write_node::depth
uint32_t depth
LocalVariableAndWriteNode#depth.
Definition ast.h:5473
pm_local_variable_and_write_node::value
struct pm_node * value
LocalVariableAndWriteNode#value.
Definition ast.h:5463
pm_local_variable_operator_write_node::depth
uint32_t depth
LocalVariableOperatorWriteNode#depth.
Definition ast.h:5521
pm_local_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
LocalVariableOperatorWriteNode#binary_operator.
Definition ast.h:5516
pm_local_variable_operator_write_node::value
struct pm_node * value
LocalVariableOperatorWriteNode#value.
Definition ast.h:5506
pm_local_variable_operator_write_node::name
pm_constant_id_t name
LocalVariableOperatorWriteNode#name.
Definition ast.h:5511
pm_local_variable_or_write_node::depth
uint32_t depth
LocalVariableOrWriteNode#depth.
Definition ast.h:5564
pm_local_variable_or_write_node::value
struct pm_node * value
LocalVariableOrWriteNode#value.
Definition ast.h:5554
pm_local_variable_or_write_node::name
pm_constant_id_t name
LocalVariableOrWriteNode#name.
Definition ast.h:5559
pm_local_variable_read_node::depth
uint32_t depth
LocalVariableReadNode#depth.
Definition ast.h:5610
pm_local_variable_read_node::name
pm_constant_id_t name
LocalVariableReadNode#name.
Definition ast.h:5597
pm_local_variable_target_node::depth
uint32_t depth
LocalVariableTargetNode#depth.
Definition ast.h:5638
pm_local_variable_target_node::name
pm_constant_id_t name
LocalVariableTargetNode#name.
Definition ast.h:5633
pm_local_variable_write_node::value
struct pm_node * value
LocalVariableWriteNode#value.
Definition ast.h:5707
pm_local_variable_write_node::depth
uint32_t depth
LocalVariableWriteNode#depth.
Definition ast.h:5680
pm_local_variable_write_node::name
pm_constant_id_t name
LocalVariableWriteNode#name.
Definition ast.h:5667
pm_location_t
This represents a range of bytes in the source string to which a node or token corresponds.
Definition ast.h:545
pm_location_t::start
const uint8_t * start
A pointer to the start location of the range in the source.
Definition ast.h:547
pm_location_t::end
const uint8_t * end
A pointer to the end location of the range in the source.
Definition ast.h:550
pm_match_predicate_node::pattern
struct pm_node * pattern
MatchPredicateNode#pattern.
Definition ast.h:5796
pm_match_predicate_node::value
struct pm_node * value
MatchPredicateNode#value.
Definition ast.h:5791
pm_match_required_node::value
struct pm_node * value
MatchRequiredNode#value.
Definition ast.h:5824
pm_match_required_node::pattern
struct pm_node * pattern
MatchRequiredNode#pattern.
Definition ast.h:5829
pm_match_write_node::targets
struct pm_node_list targets
MatchWriteNode#targets.
Definition ast.h:5862
pm_match_write_node::call
struct pm_call_node * call
MatchWriteNode#call.
Definition ast.h:5857
pm_module_node::constant_path
struct pm_node * constant_path
ModuleNode#constant_path.
Definition ast.h:5910
pm_module_node::body
struct pm_node * body
ModuleNode#body.
Definition ast.h:5915
pm_module_node::locals
pm_constant_id_list_t locals
ModuleNode#locals.
Definition ast.h:5900
pm_module_node::name
pm_constant_id_t name
ModuleNode#name.
Definition ast.h:5925
pm_multi_target_node::lefts
struct pm_node_list lefts
MultiTargetNode#lefts.
Definition ast.h:5963
pm_multi_target_node::rest
struct pm_node * rest
MultiTargetNode#rest.
Definition ast.h:5983
pm_multi_target_node::rights
struct pm_node_list rights
MultiTargetNode#rights.
Definition ast.h:5993
pm_multi_target_state_node
This is a node in the multi target state linked list.
Definition prism_compile.c:4756
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:4782
pm_multi_write_node::value
struct pm_node * value
MultiWriteNode#value.
Definition ast.h:6116
pm_multi_write_node::rest
struct pm_node * rest
MultiWriteNode#rest.
Definition ast.h:6066
pm_multi_write_node::rights
struct pm_node_list rights
MultiWriteNode#rights.
Definition ast.h:6076
pm_multi_write_node::lefts
struct pm_node_list lefts
MultiWriteNode#lefts.
Definition ast.h:6046
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:6139
pm_node_list::size
size_t size
The number of nodes in the list.
Definition ast.h:560
pm_node_list::nodes
struct pm_node ** nodes
The nodes in the list.
Definition ast.h:566
pm_node_location_t
This compiler defines its own concept of the location of a node.
Definition prism_compile.c:8
pm_node_location_t::line
int32_t line
This is the line number of a node.
Definition prism_compile.c:10
pm_node_location_t::node_id
uint32_t node_id
This is a unique identifier for the node.
Definition prism_compile.c:13
pm_node::type
pm_node_type_t type
This represents the type of the node.
Definition ast.h:1074
pm_node::node_id
uint32_t node_id
The unique identifier for this node, which is deterministic based on the source.
Definition ast.h:1086
pm_node::flags
pm_node_flags_t flags
This represents any flags on the node.
Definition ast.h:1080
pm_node::location
pm_location_t location
This is the location of the node in the source.
Definition ast.h:1092
pm_numbered_reference_read_node::number
uint32_t number
NumberedReferenceReadNode#number.
Definition ast.h:6245
pm_optional_keyword_parameter_node::name
pm_constant_id_t name
OptionalKeywordParameterNode#name.
Definition ast.h:6272
pm_optional_keyword_parameter_node::value
struct pm_node * value
OptionalKeywordParameterNode#value.
Definition ast.h:6282
pm_optional_parameter_node::value
struct pm_node * value
OptionalParameterNode#value.
Definition ast.h:6324
pm_optional_parameter_node::name
pm_constant_id_t name
OptionalParameterNode#name.
Definition ast.h:6309
pm_or_node::left
struct pm_node * left
OrNode#left.
Definition ast.h:6355
pm_or_node::right
struct pm_node * right
OrNode#right.
Definition ast.h:6368
pm_parameters_node::rest
struct pm_node * rest
ParametersNode#rest.
Definition ast.h:6412
pm_parameters_node::requireds
struct pm_node_list requireds
ParametersNode#requireds.
Definition ast.h:6402
pm_parameters_node::block
struct pm_block_parameter_node * block
ParametersNode#block.
Definition ast.h:6432
pm_parameters_node::optionals
struct pm_node_list optionals
ParametersNode#optionals.
Definition ast.h:6407
pm_parameters_node::posts
struct pm_node_list posts
ParametersNode#posts.
Definition ast.h:6417
pm_parameters_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6396
pm_parameters_node::keyword_rest
struct pm_node * keyword_rest
ParametersNode#keyword_rest.
Definition ast.h:6427
pm_parameters_node::keywords
struct pm_node_list keywords
ParametersNode#keywords.
Definition ast.h:6422
pm_parentheses_node::body
struct pm_node * body
ParenthesesNode#body.
Definition ast.h:6455
pm_parse_error_format_t
The format that will be used to format the errors into the output.
Definition prism_compile.c:10499
pm_parse_error_format_t::blank_prefix_length
size_t blank_prefix_length
The length of the blank prefix.
Definition prism_compile.c:10510
pm_parse_error_format_t::blank_prefix
const char * blank_prefix
The prefix that will be used for blank lines.
Definition prism_compile.c:10504
pm_parse_error_format_t::divider_length
size_t divider_length
The length of the divider.
Definition prism_compile.c:10513
pm_parse_error_format_t::number_prefix
const char * number_prefix
The prefix that will be used for line numbers.
Definition prism_compile.c:10501
pm_parse_error_format_t::divider
const char * divider
The divider that will be used between sections of source code.
Definition prism_compile.c:10507
pm_parse_error_t
An error that is going to be formatted into the output.
Definition prism_compile.c:10484
pm_parse_error_t::error
pm_diagnostic_t * error
A pointer to the diagnostic that was generated during parsing.
Definition prism_compile.c:10486
pm_parse_error_t::column_end
uint32_t column_end
The column end of the diagnostic message.
Definition prism_compile.c:10495
pm_parse_error_t::line
int32_t line
The start line of the diagnostic message.
Definition prism_compile.c:10489
pm_parse_error_t::column_start
uint32_t column_start
The column start of the diagnostic message.
Definition prism_compile.c:10492
pm_parse_result_t
Definition prism_compile.h:69
pm_parse_result_t::parsed
bool parsed
Whether or not this parse result has performed its parsing yet.
Definition prism_compile.h:83
pm_parse_result_t::node
pm_scope_node_t node
The resulting scope node that will hold the generated AST.
Definition prism_compile.h:80
pm_parse_result_t::input
pm_string_t input
The input that represents the source to be parsed.
Definition prism_compile.h:77
pm_parse_result_t::parser
pm_parser_t parser
The parser that will do the actual parsing.
Definition prism_compile.h:71
pm_parse_result_t::options
pm_options_t options
The options that will be passed to the parser.
Definition prism_compile.h:74
pm_parser::encoding
const pm_encoding_t * encoding
The encoding functions for the current file is attached to the parser as it's parsing so that it can ...
Definition parser.h:755
pm_parser::end
const uint8_t * end
The pointer to the end of the source.
Definition parser.h:694
pm_parser::constant_pool
pm_constant_pool_t constant_pool
This constant pool keeps all of the constants defined throughout the file so that we can reference th...
Definition parser.h:786
pm_parser::start
const uint8_t * start
The pointer to the start of the source.
Definition parser.h:691
pm_parser::error_list
pm_list_t error_list
The list of errors that have been found while parsing.
Definition parser.h:734
pm_parser::warning_list
pm_list_t warning_list
The list of warnings that have been found while parsing.
Definition parser.h:731
pm_parser::start_line
int32_t start_line
The line number at the start of the parse.
Definition parser.h:809
pm_parser::filepath
pm_string_t filepath
This is the path of the file being parsed.
Definition parser.h:780
pm_parser::newline_list
pm_newline_list_t newline_list
This is the list of newline offsets in the source file.
Definition parser.h:789
pm_pinned_variable_node::variable
struct pm_node * variable
PinnedVariableNode#variable.
Definition ast.h:6526
pm_post_execution_node::statements
struct pm_statements_node * statements
PostExecutionNode#statements.
Definition ast.h:6554
pm_pre_execution_node::statements
struct pm_statements_node * statements
PreExecutionNode#statements.
Definition ast.h:6592
pm_program_node::statements
struct pm_statements_node * statements
ProgramNode#statements.
Definition ast.h:6632
pm_range_node::right
struct pm_node * right
RangeNode#right.
Definition ast.h:6683
pm_range_node::left
struct pm_node * left
RangeNode#left.
Definition ast.h:6669
pm_rational_node::denominator
pm_integer_t denominator
RationalNode#denominator.
Definition ast.h:6732
pm_rational_node::numerator
pm_integer_t numerator
RationalNode#numerator.
Definition ast.h:6723
pm_required_parameter_node::name
pm_constant_id_t name
RequiredParameterNode#name.
Definition ast.h:6860
pm_rescue_modifier_node::rescue_expression
struct pm_node * rescue_expression
RescueModifierNode#rescue_expression.
Definition ast.h:6893
pm_rescue_modifier_node::expression
struct pm_node * expression
RescueModifierNode#expression.
Definition ast.h:6883
pm_rescue_node::subsequent
struct pm_rescue_node * subsequent
RescueNode#subsequent.
Definition ast.h:6946
pm_rescue_node::reference
struct pm_node * reference
RescueNode#reference.
Definition ast.h:6936
pm_rescue_node::exceptions
struct pm_node_list exceptions
RescueNode#exceptions.
Definition ast.h:6926
pm_rescue_node::statements
struct pm_statements_node * statements
RescueNode#statements.
Definition ast.h:6941
pm_return_node::arguments
struct pm_arguments_node * arguments
ReturnNode#arguments.
Definition ast.h:7029
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:7078
pm_shareable_constant_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7070
pm_singleton_class_node::locals
pm_constant_id_list_t locals
SingletonClassNode#locals.
Definition ast.h:7101
pm_singleton_class_node::expression
struct pm_node * expression
SingletonClassNode#expression.
Definition ast.h:7116
pm_singleton_class_node::body
struct pm_node * body
SingletonClassNode#body.
Definition ast.h:7121
pm_source_file_node::filepath
pm_string_t filepath
SourceFileNode#filepath.
Definition ast.h:7175
pm_splat_node::expression
struct pm_node * expression
SplatNode#expression.
Definition ast.h:7221
pm_statements_node::body
struct pm_node_list body
StatementsNode#body.
Definition ast.h:7244
pm_statements_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7238
pm_string_node::unescaped
pm_string_t unescaped
StringNode#unescaped.
Definition ast.h:7294
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:7330
pm_super_node::block
struct pm_node * block
SuperNode#block.
Definition ast.h:7340
pm_symbol_node::unescaped
pm_string_t unescaped
SymbolNode#unescaped.
Definition ast.h:7386
pm_symbol_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7365
pm_undef_node::names
struct pm_node_list names
UndefNode#names.
Definition ast.h:7427
pm_unless_node::statements
struct pm_statements_node * statements
UnlessNode#statements.
Definition ast.h:7500
pm_unless_node::predicate
struct pm_node * predicate
UnlessNode#predicate.
Definition ast.h:7479
pm_unless_node::else_clause
struct pm_else_node * else_clause
UnlessNode#else_clause.
Definition ast.h:7510
pm_until_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7543
pm_while_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7632
pm_x_string_node::unescaped
pm_string_t unescaped
XStringNode#unescaped.
Definition ast.h:7700
pm_yield_node::arguments
struct pm_arguments_node * arguments
YieldNode#arguments.
Definition ast.h:7733
rb_builtin_function
Definition builtin.h:6
rb_callinfo_kwarg
Definition vm_callinfo.h:48
rb_callinfo
Definition vm_callinfo.h:65
rb_iseq_constant_body
Definition vm_core.h:404
rb_iseq_constant_body::param
struct rb_iseq_constant_body::@000024342312237062266020177166377106262102236123 param
parameter information
rb_iseq_new_with_callback_callback_func
Definition vm_core.h:1233
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