--flavor cppflags="${INPUT_CPPFLAGS}" \

--test-suite test-spec \

> "${builddir}"/${test_spec_session_file} \

fi

}

launchable_record_test() {

btest_session_file='launchable_btest_session.txt'

test_spec_session_file='launchable_test_spec_session.txt'

setup_pid=$$

launchable_failed=false

trap "launchable_failed=true" INT

setup_launchable

post: |

rm -f "${test_all_session_file}"

rm -f "${btest_session_file}"

if: always() && steps.setup-launchable.outcome == 'success'

env:

test_all_session_file: ${{ steps.global.outputs.test_all_session_file }}

EMAIL: [email protected]

GIT_AUTHOR_NAME: git

GIT_COMMITTER_NAME: git

PUSH_REF: ${{ github.ref == 'refs/heads/master' && github.ref || '' }}

- name: Check if C-sources are US-ASCII

run: |

- name: Wait for status checks

uses: lewagon/wait-on-check-action@ccfb013c15c8afb7bf2b7c028fb74dc5a068cccc # v1.3.4

with:

ref: ${{ github.event.pull_request.head.sha || github.sha }}

check-regexp: 'make \(check, .*\)'

wait-interval: 30

## Compatibility issues

* `Ractor.yield`

* `Ractor#take`

location_new(&RNODE_CLASS(node)->class_keyword_loc),

location_new(&RNODE_CLASS(node)->inheritance_operator_loc),

location_new(&RNODE_CLASS(node)->end_keyword_loc));

case NODE_DOT2:

return rb_ary_new_from_args(2,

location_new(nd_code_loc(node)),

--filter REGEXP Filter out benchmarks with given regexp

--run-duration SECONDS Warmup estimates loop_count to run for this duration (default: 3)

--timeout SECONDS Timeout ruby command execution with timeout(1)

```

## make benchmark

call(Sub.new('o')).class

}

assert_equal '["str", "ivar"]', %q{

def str_dup(str) = str.dup

str = "str"

RCLASSEXT_M_TBL(ext) = duplicate_classext_m_tbl(RCLASSEXT_M_TBL(orig), klass, dup_iclass);

if (orig->fields_obj) {

}

if (RCLASSEXT_SHARED_CONST_TBL(orig)) {

if (!ap->name) {

return -1;

return 1;

}

RB_DEBUG_COUNTER(obj_imemo_callinfo)

RB_DEBUG_COUNTER(obj_imemo_callcache)

RB_DEBUG_COUNTER(obj_imemo_constcache)

RB_DEBUG_COUNTER(opt_new_hit)

RB_DEBUG_COUNTER(opt_new_miss)

The tarball for official releases is created by the release manager. The release manager uploads the tarball to the [Ruby website](https://www.ruby-lang.org/en/downloads/).

### Using the nightly tarball for testing

RB_OBJ_WRITTEN(hash, Qundef, tally);

}

*value = (st_data_t)tally;

return ST_CONTINUE;

}

static VALUE

rb_enum_tally_up(VALUE hash, VALUE group)

{

return hash;

}

if (simple_dat_p(x)) {

r = m_real_jd(x);

long ir = FIX2LONG(r);

ir = ir * 2 - 1;

return rb_rational_new2(LONG2FIX(ir), INT2FIX(2));

static VALUE

d_lite_hash(VALUE self)

{

get_d1(self);

v = rb_memhash(h, sizeof(h));

return ST2FIX(v);

}

# to string interpolation.

#

# Note: no validation is performed on the provided string. It is the

Fragment = Struct.new(:json) do

def initialize(json)

unless string = String.try_convert(json)

INIT_IMEMO_TYPE_ID(imemo_callinfo);

INIT_IMEMO_TYPE_ID(imemo_callcache);

INIT_IMEMO_TYPE_ID(imemo_constcache);

#undef INIT_IMEMO_TYPE_ID

}

dc->cur_obj = obj;

dc->cur_obj_references = 0;

dc->cur_obj_klass = 0;

dc->cur_obj_klass = RBASIC_CLASS(obj);

}

dump_append(dc, obj_type(obj));

dump_append(dc, "\"");

dump_append(dc, ", \"shape_id\":");

dump_append_sizet(dc, shape_id);

}

#

# [:resolv_timeout] Specifies the timeout in seconds from when the hostname resolution starts.

# [:connect_timeout] This method sequentially attempts connecting to all candidate destination addresses.<br>The +connect_timeout+ specifies the timeout in seconds from the start of the connection attempt to the last candidate.<br>By default, all connection attempts continue until the timeout occurs.<br>When +fast_fallback:false+ is explicitly specified,<br>a timeout is set for each connection attempt and any connection attempt that exceeds its timeout will be canceled.

# [:fast_fallback] Enables the Happy Eyeballs Version 2 algorithm (enabled by default).

#

# If a block is given, the block is called with the socket.

# sock.close_write

# puts sock.read

# }

sock = if fast_fallback && !(host && ip_address?(host))

else

end

if block_given?

end

end

if local_host || local_port

local_addrinfos = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, timeout: resolv_timeout)

resolving_family_names = local_addrinfos.map { |lai| ADDRESS_FAMILIES.key(lai.afamily) }.uniq

resolution_delay_expires_at = nil

connection_attempt_delay_expires_at = nil

user_specified_connect_timeout_at = nil

last_error = nil

last_error_from_thread = false

ends_at =

if resolution_store.any_addrinfos?

else

[user_specified_resolv_timeout_at, user_specified_connect_timeout_at].compact.max

end

end

end

if resolution_store.empty_addrinfos?

if connecting_sockets.empty? && resolution_store.resolved_all_families?

if last_error_from_thread

end

end

last_error = nil

ret = nil

local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil)

end

if local_addr_list

local_addr = local_addr_list.find {|local_ai| local_ai.afamily == ai.afamily }

next unless local_addr

local_addr = nil

end

begin

sock = local_addr ?

rescue SystemCallError

last_error = $!

next

# Replace %\w+% into the environment value of what is contained between the %'s

# This method is used for REG_EXPAND_SZ.

#

#

def self.expand_environ(str)

str.gsub(Regexp.compile("%([^%]+)%".encode(str.encoding))) {

ObjectSpace.define_finalizer self, @@final.call(@hkeyfinal)

end

attr_reader :parent

# Same as subkey value of Registry.open or

# Registry.create method.

# For each value it yields key, type and data.

#

# key is a String which contains name of key.

# data is the value of this key.

#

def each_value

static inline void

obj_free_object_id(VALUE obj)

{

VALUE obj_id = 0;

if (RB_UNLIKELY(id2ref_tbl)) {

switch (BUILTIN_TYPE(obj)) {

case T_MODULE:

obj_id = RCLASS(obj)->object_id;

break;

shape_id_t shape_id = RBASIC_SHAPE_ID(obj);

if (rb_shape_has_object_id(shape_id)) {

obj_id = object_id_get(obj, shape_id);

}

break;

}

}

if (RB_UNLIKELY(obj_id)) {

RUBY_ASSERT(FIXNUM_P(obj_id) || RB_TYPE_P(obj_id, T_BIGNUM));

if (!st_delete(id2ref_tbl, (st_data_t *)&obj_id, NULL)) {

rb_bug("Object ID seen, but not in _id2ref table: object_id=%llu object=%s", NUM2ULL(obj_id), rb_obj_info(obj));

}

}

obj_free_object_id(obj);

if (rb_obj_exivar_p(obj)) {

}

switch (BUILTIN_TYPE(obj)) {

return 0;

}

switch (BUILTIN_TYPE(obj)) {

case T_OBJECT:

if (rb_shape_obj_too_complex_p(obj)) {

MARK_CHECKPOINT("vm");

rb_vm_mark(vm);

MARK_CHECKPOINT("end_proc");

rb_mark_end_proc();

return iter_data->update_callback((VALUE *)value, iter_data->data);

}

struct st_table *rb_generic_fields_tbl_get(void);

static int

int ret = iter_data->callback((VALUE)key, iter_data->data);

switch (ret) {

case ST_CONTINUE:

break;

case ST_DELETE:

RBASIC_SET_SHAPE_ID((VALUE)key, ROOT_SHAPE_ID);

return ST_DELETE;

case ST_REPLACE: {

ret = iter_data->update_callback(&new_key, iter_data->data);

}

break;

}

default:

}

if (!iter_data->weak_only) {

}

}

}

return ret;

break;

}

case RB_GC_VM_WEAK_TABLE_COUNT:

default:

rb_bug("rb_gc_vm_weak_table_foreach: unknown table %d", table);

}

}

rb_ary_set_len(values, size);

}

else {

rb_hash_foreach(hash, values_i, values);

}

IMEMO_NAME(svar);

IMEMO_NAME(throw_data);

IMEMO_NAME(tmpbuf);

#undef IMEMO_NAME

}

rb_bug("unreachable");

}

static VALUE

{

if (rb_gc_size_allocatable_p(embedded_size)) {

return fields;

}

else {

FL_SET_RAW(fields, OBJ_FIELD_EXTERNAL);

IMEMO_OBJ_FIELDS(fields)->as.external.ptr = ALLOC_N(VALUE, capa);

return fields;

}

VALUE

{

}

static VALUE

{

IMEMO_OBJ_FIELDS(fields)->as.complex.table = st_init_numtable_with_size(capa);

return fields;

}

VALUE

{

}

VALUE

{

shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);

VALUE clone;

if (rb_shape_too_complex_p(shape_id)) {

RBASIC_SET_SHAPE_ID(clone, shape_id);

}

else {

RBASIC_SET_SHAPE_ID(clone, shape_id);

}

return clone;

}

/* =========================================================================

* memsize

* ========================================================================= */

size += ((rb_imemo_tmpbuf_t *)obj)->cnt * sizeof(VALUE);

break;

if (rb_shape_obj_too_complex_p(obj)) {

size += st_memsize(IMEMO_OBJ_FIELDS(obj)->as.complex.table);

}

break;

}

rb_gc_mark_and_move((VALUE *)&RBASIC(obj)->klass);

if (rb_shape_obj_too_complex_p(obj)) {

if (reference_updating) {

rb_gc_ref_update_table_values_only(tbl);

}

}

}

else {

attr_index_t len = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));

for (attr_index_t i = 0; i < len; i++) {

rb_gc_mark_and_move(&fields[i]);

}

static inline void

{

if (rb_shape_obj_too_complex_p((VALUE)fields)) {

st_free_table(fields->as.complex.table);

RB_DEBUG_COUNTER_INC(obj_imemo_tmpbuf);

break;

break;

default:

rb_bug("unreachable");

= 0,

/**

* This flag has something to do with Ractor. Multiple Ractors run without

* protecting each other. Sharing an object among Ractors are basically

* dangerous, disabled by default. This flag is used to bypass that

*/

RUBY_FL_UNUSED9 = (1<<9),

/**

* This flag has something to do with data immutability. When this flag is

# pragma deprecated(RUBY_FL_DUPPED)

#endif

};

#undef RBIMPL_HAVE_ENUM_ATTRIBUTE

RCLASS_EXT_WRITABLE(VALUE obj)

{

const rb_namespace_t *ns;

return RCLASS_EXT_PRIME(obj);

}

// delay namespace loading to optimize for unmodified classes

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

rb_classext_t *ext = RCLASS_EXT_WRITABLE(obj);

if (!ext->fields_obj) {

}

return ext->fields_obj;

}

VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);

if (fields_obj) {

if (rb_shape_obj_too_complex_p(fields_obj)) {

}

else {

return RSHAPE_LEN(RBASIC_SHAPE_ID(fields_obj));

imemo_callinfo = 11,

imemo_callcache = 12,

imemo_constcache = 13,

};

/* CREF (Class REFerence) is defined in method.h */

RB_OBJ_WRITE(m, &m->v2, v);

}

struct RBasic basic;

union {

struct {

};

#define OBJ_FIELD_EXTERNAL IMEMO_FL_USER0

static inline VALUE *

{

if (!obj_fields) {

return NULL;

}

if (RB_UNLIKELY(FL_TEST_RAW(obj_fields, OBJ_FIELD_EXTERNAL))) {

return IMEMO_OBJ_FIELDS(obj_fields)->as.external.ptr;

}

static inline st_table *

{

if (!obj_fields) {

return NULL;

}

return IMEMO_OBJ_FIELDS(obj_fields)->as.complex.table;

}

int rb_threadptr_execute_interrupts(struct rb_thread_struct *th, int blocking_timing);

bool rb_thread_mn_schedulable(VALUE thread);

// interrupt exec

typedef VALUE (rb_interrupt_exec_func_t)(void *data);

/* variable.c */

void rb_gc_mark_global_tbl(void);

void rb_gc_update_global_tbl(void);

VALUE rb_search_class_path(VALUE);

VALUE rb_attr_delete(VALUE, ID);

void rb_autoload_str(VALUE mod, ID id, VALUE file);

*/

VALUE rb_mod_set_temporary_name(VALUE, VALUE);

void rb_obj_copy_ivs_to_hash_table(VALUE obj, st_table *table);

void rb_obj_init_too_complex(VALUE obj, st_table *table);

void rb_evict_ivars_to_hash(VALUE obj);

}

static void

rb_io_buffer_type_free(void *_buffer)

{

struct rb_io_buffer *buffer = _buffer;

return total;

}

static const rb_data_type_t rb_io_buffer_type = {

.wrap_struct_name = "IO::Buffer",

.function = {

.dfree = rb_io_buffer_type_free,

.dsize = rb_io_buffer_type_size,

},

.data = NULL,

};

static inline enum rb_io_buffer_flags

arguments->instance = io_buffer_for_make_instance(arguments->klass, arguments->string, arguments->flags);

return rb_yield(arguments->instance);

}

rb_io_buffer_free(arguments->instance);

}

return Qnil;

}

ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path)

require_relative "rubygems/user_interaction"

begin

Gem::DefaultUserInteraction.use_ui(ui) do

Bundler.ui.silence do

# Install requested gems after they have been downloaded

sorted_requests.each do |req|

req.spec.spec.build_extensions

end

spec =

# require 'tempfile'

#

# # Tempfile.create with a block

# # (You can specify the prefix and suffix of the filename by an optional argument.)

# Tempfile.create {|f|

# f.puts "foo"

compat_allocator_table();

compat = ALLOC(marshal_compat_t);

compat->dumper = dumper;

compat->loader = loader;

st_insert(compat_allocator_table(), (st_data_t)allocator, (st_data_t)compat);

}

struct dump_arg {

flags = [

"RUBY_FL_WB_PROTECTED", "RUBY_FL_PROMOTED", "RUBY_FL_FINALIZE",

"RUBY_FL_USER0", "RUBY_FL_USER1", "RUBY_FL_USER2", "RUBY_FL_USER3", "RUBY_FL_USER4",

"RUBY_FL_USER5", "RUBY_FL_USER6", "RUBY_FL_USER7", "RUBY_FL_USER8", "RUBY_FL_USER9",

"RUBY_FL_USER10", "RUBY_FL_USER11", "RUBY_FL_USER12", "RUBY_FL_USER13", "RUBY_FL_USER14",

ANN("format: [nd_head]::[nd_mid]");

ANN("example: M::C");

F_ID(nd_mid, RNODE_COLON2, "constant name");

F_NODE(nd_head, RNODE_COLON2, "receiver");

return;

case NODE_COLON3:

ANN("format: ::[nd_mid]");

ANN("example: ::Object");

F_ID(nd_mid, RNODE_COLON3, "constant name");

return;

case NODE_DOT2:

RBASIC(dest)->flags |= RBASIC(obj)->flags & T_MASK;

switch (BUILTIN_TYPE(obj)) {

case T_IMEMO:

break;

case T_CLASS:

case T_MODULE:

static rb_node_class_t *rb_node_class_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, NODE *nd_super, const YYLTYPE *loc, const YYLTYPE *class_keyword_loc, const YYLTYPE *inheritance_operator_loc, const YYLTYPE *end_keyword_loc);

static rb_node_module_t *rb_node_module_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, const YYLTYPE *loc);

static rb_node_sclass_t *rb_node_sclass_new(struct parser_params *p, NODE *nd_recv, NODE *nd_body, const YYLTYPE *loc);

static rb_node_dot2_t *rb_node_dot2_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc, const YYLTYPE *operator_loc);

static rb_node_dot3_t *rb_node_dot3_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc, const YYLTYPE *operator_loc);

static rb_node_self_t *rb_node_self_new(struct parser_params *p, const YYLTYPE *loc);

#define NEW_CLASS(n,b,s,loc,ck_loc,io_loc,ek_loc) (NODE *)rb_node_class_new(p,n,b,s,loc,ck_loc,io_loc,ek_loc)

#define NEW_MODULE(n,b,loc) (NODE *)rb_node_module_new(p,n,b,loc)

#define NEW_SCLASS(r,b,loc) (NODE *)rb_node_sclass_new(p,r,b,loc)

#define NEW_DOT2(b,e,loc,op_loc) (NODE *)rb_node_dot2_new(p,b,e,loc,op_loc)

#define NEW_DOT3(b,e,loc,op_loc) (NODE *)rb_node_dot3_new(p,b,e,loc,op_loc)

#define NEW_SELF(loc) (NODE *)rb_node_self_new(p,loc)

| primary_value tCOLON2 tCONSTANT tOP_ASGN lex_ctxt rhs

{

YYLTYPE loc = code_loc_gen(&@primary_value, &@tCONSTANT);

/*% ripper: opassign!(const_path_field!($:1, $:3), $:4, $:6) %*/

}

| tCOLON3 tCONSTANT tOP_ASGN lex_ctxt rhs

{

YYLTYPE loc = code_loc_gen(&@tCOLON3, &@tCONSTANT);

/*% ripper: opassign!(top_const_field!($:2), $:3, $:5) %*/

}

| backref tOP_ASGN lex_ctxt rhs

| primary_value tCOLON2 tCONSTANT

{

/*% ripper: const_path_field!($:1, $:3) %*/

}

| tCOLON3 tCONSTANT

{

/*% ripper: top_const_field!($:2) %*/

}

| backref

{

| primary_value tCOLON2 tCONSTANT

{

/*% ripper: const_path_field!($:1, $:3) %*/

}

| tCOLON3 tCONSTANT

{

/*% ripper: top_const_field!($:2) %*/

}

| backref

{

cpath : tCOLON3 cname

{

/*% ripper: top_const_ref!($:2) %*/

}

| cname

{

/*% ripper: const_ref!($:1) %*/

}

| primary_value tCOLON2 cname

{

/*% ripper: const_path_ref!($:1, $:3) %*/

}

;

}

| primary_value tCOLON2 tCONSTANT

{

/*% ripper: const_path_ref!($:1, $:3) %*/

}

| tCOLON3 tCONSTANT

{

/*% ripper: top_const_ref!($:2) %*/

}

| tLBRACK aref_args ']'

p_const : tCOLON3 cname

{

/*% ripper: top_const_ref!($:2) %*/

}

| p_const tCOLON2 cname

{

/*% ripper: const_path_ref!($:1, $:3) %*/

}

| tCONSTANT

}

static rb_node_colon2_t *

{

rb_node_colon2_t *n = NODE_NEWNODE(NODE_COLON2, rb_node_colon2_t, loc);

n->nd_head = nd_head;

n->nd_mid = nd_mid;

return n;

}

static rb_node_colon3_t *

{

rb_node_colon3_t *n = NODE_NEWNODE(NODE_COLON3, rb_node_colon3_t, loc);

n->nd_mid = nd_mid;

return n;

}

RARRAY_ASET(sym_proc_cache, index, procval);

return RB_GC_GUARD(procval);

return sym_proc_new(rb_cProc, sym);

}

}

}

switch (TYPE(obj)) {

}

if (!RB_OBJ_FROZEN_RAW(obj)) {

} while (0)

if (UNLIKELY(rb_obj_exivar_p(obj))) {

if (UNLIKELY(rb_shape_obj_too_complex_p(obj))) {

struct obj_traverse_replace_callback_data d = {

.src = obj,

};

rb_st_foreach_with_replace(

obj_iv_hash_traverse_replace_foreach_i,

obj_iv_hash_traverse_replace_i,

(st_data_t)&d

}

else {

uint32_t fields_count = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));

for (uint32_t i = 0; i < fields_count; i++) {

}

}

}

return reg_cache;

return reg_cache = rb_reg_new_str(str, 0);

return rb_reg_new_str(str, 0);

}

}

struct RNode *nd_head;

ID nd_mid;

} rb_node_colon2_t;

typedef struct RNode_COLON3 {

NODE node;

ID nd_mid;

} rb_node_colon3_t;

/* NODE_DOT2, NODE_DOT3, NODE_FLIP2, NODE_FLIP3 */

#define RNODE_FILE(node) ((rb_node_file_t *)(node))

#define RNODE_ENCODING(node) ((rb_node_encoding_t *)(node))

/* NODE_FL: 0..4: UNUSED, 5: UNUSED, 6: UNUSED, 7: NODE_FL_NEWLINE,

* 8..14: nd_type,

* 15..: nd_line

struct rb_fiber_scheduler_blocking_operation {

void *(*function)(void *);

void *data;

rb_unblock_function_t *unblock_function;

void *data2;

int flags;

struct rb_fiber_scheduler_blocking_operation_state *state;

return -1; // Invalid blocking operation

}

rb_atomic_t expected = RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_QUEUED;

if (RUBY_ATOMIC_CAS(blocking_operation->status, expected, RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_EXECUTING) != expected) {

// Already cancelled or in wrong state

rb_atomic_t current_state = RUBY_ATOMIC_LOAD(blocking_operation->status);

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_QUEUED:

if (RUBY_ATOMIC_CAS(blocking_operation->status, current_state, RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_CANCELLED) == current_state) {

}

// Fall through if state changed between load and CAS

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_EXECUTING:

// Work is running - mark cancelled AND call unblock function

blocking_operation->unblock_function(blocking_operation->data2);

}

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_COMPLETED:

case RB_FIBER_SCHEDULER_BLOCKING_OPERATION_STATUS_CANCELLED:

return 0;

}

#endif

VALUE klass;

klass = CLASS_OF(obj);

}

else {

}

else {

if (flags_heap_index) {

}

}

return true;

}

#endif

RBASIC_SHAPE_ID(VALUE obj)

{

RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));

#if RBASIC_SHAPE_ID_FIELD

return (shape_id_t)((RBASIC(obj)->shape_id));

#else

RBASIC_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)

{

RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));

#if RBASIC_SHAPE_ID_FIELD

RBASIC(obj)->shape_id = (VALUE)shape_id;

#else

it "has no rubocop offenses when using --ext=rust and --linter=rubocop flag" do

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle "gem #{gem_name} --ext=rust --linter=rubocop"

bundle_exec_rubocop

it "has no rubocop offenses when using --ext=rust, --test=minitest, and --linter=rubocop flag" do

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle "gem #{gem_name} --ext=rust --test=minitest --linter=rubocop"

bundle_exec_rubocop

it "has no rubocop offenses when using --ext=rust, --test=rspec, and --linter=rubocop flag" do

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle "gem #{gem_name} --ext=rust --test=rspec --linter=rubocop"

bundle_exec_rubocop

it "has no rubocop offenses when using --ext=rust, --test=test-unit, and --linter=rubocop flag" do

skip "ruby_core has an 'ast.rb' file that gets in the middle and breaks this spec" if ruby_core?

bundle "gem #{gem_name} --ext=rust --test=test-unit --linter=rubocop"

bundle_exec_rubocop

end

end

context "--ext parameter set with rust" do

let(:flags) { "--ext=rust" }

before do

bundle ["gem", gem_name, flags].compact.join(" ")

end

# frozen_string_literal: true

RSpec.describe "fetching dependencies with a not available mirror" do

let(:host) { "127.0.0.1" }

before do

context "with a specific fallback timeout" do

before do

end

it "install a gem using the original uri when the mirror is not responding" do

gemfile <<-G

gem 'weakling'

G

context "with a global fallback timeout" do

before do

global_config("BUNDLE_MIRROR__ALL__FALLBACK_TIMEOUT/" => "1",

end

it "install a gem using the original uri when the mirror is not responding" do

gemfile <<-G

gem 'weakling'

G

context "with a specific mirror without a fallback timeout" do

before do

end

gemfile <<-G

gem 'weakling'

G

bundle :install, artifice: nil, raise_on_error: false

err_lines = err.split("\n")

end

end

context "with a global mirror without a fallback timeout" do

before do

end

gemfile <<-G

gem 'weakling'

G

bundle :install, artifice: nil, raise_on_error: false

err_lines = err.split("\n")

end

end

@server_port = find_unused_port

@server_uri = "http://#{host}:#{@server_port}"

require_relative "../../support/silent_logger"

require "rackup/server"

@server_thread = Thread.new do

Host: host,

Port: @server_port,

server: "webrick",

it "works and points to the vendored copies, not to the default copies" do

necessary_gems_in_bundle_path = ["optparse --version 0.1.1", "psych --version 3.3.2", "logger --version 1.4.3", "etc --version 1.4.3", "stringio --version 3.1.0"]

realworld_system_gems(*necessary_gems_in_bundle_path, path: scoped_gem_path(bundled_app("bundle")))

build_gem "foo", "1.0.0", to_system: true, default: true do |s|

it "works for gems with extensions and points to the vendored copies, not to the default copies" do

simulate_platform "arm64-darwin-23" do

necessary_gems_in_bundle_path = ["optparse --version 0.1.1", "psych --version 3.3.2", "logger --version 1.4.3", "etc --version 1.4.3", "stringio --version 3.1.0", "shellwords --version 0.2.0", "open3 --version 0.2.1"]

realworld_system_gems(*necessary_gems_in_bundle_path, path: scoped_gem_path(bundled_app("bundle")))

build_gem "baz", "1.0.0", to_system: true, default: true, &:add_c_extension

describe "default gem activation" do

let(:exemptions) do

exempts = %w[did_you_mean bundler uri pathname]

exempts << "error_highlight" # added in Ruby 3.1 as a default gem

exempts << "ruby2_keywords" # added in Ruby 3.1 as a default gem

exempts << "syntax_suggest" # added in Ruby 3.2 as a default gem

require_relative 'spec_helper'

load_extension('digest')

-> { str.upcase! }.should raise_error(RuntimeError, 'can\'t modify string; temporarily locked')

end

it "raises FrozenError if string is frozen" do

str = -"rb_str_locktmp"

-> { @s.rb_str_locktmp(str) }.should raise_error(FrozenError)

-> { @s.rb_str_unlocktmp(+"test") }.should raise_error(RuntimeError, 'temporal unlocking already unlocked string')

end

it "raises FrozenError if string is frozen" do

str = -"rb_str_locktmp"

-> { @s.rb_str_unlocktmp(str) }.should raise_error(FrozenError)

value = entry->record;

}

old_key = key;

retval = (*func)(&key, &value, arg, existing);

switch (retval) {

case ST_CONTINUE:

if (! existing) {

RUBY_ASSERT(RB_TYPE_P(str, T_STRING));

RUBY_ASSERT(OBJ_FROZEN(str));

RUBY_ASSERT(!FL_TEST_RAW(str, STR_FAKESTR));

RUBY_ASSERT(!rb_obj_exivar_p(str));

RUBY_ASSERT(RBASIC_CLASS(str) == rb_cString);

RUBY_ASSERT(!rb_objspace_garbage_object_p(str));

VALUE

rb_str_locktmp(VALUE str)

{

if (FL_TEST(str, STR_TMPLOCK)) {

rb_raise(rb_eRuntimeError, "temporal locking already locked string");

}

VALUE

rb_str_unlocktmp(VALUE str)

{

if (!FL_TEST(str, STR_TMPLOCK)) {

rb_raise(rb_eRuntimeError, "temporal unlocking already unlocked string");

}

assert_equal(9, h[DateTime.new(1999,5,25)])

h = {}

h[DateTime.new(1999,5,23)] = 0

h[DateTime.new(1999,5,24)] = 1

h[DateTime.new(1999,5,25)] = 2

[d.year, d.mon, d.mday, d.hour, d.min, d.sec, d.offset])

end

def test_ordinal

d = Date.ordinal

assert_equal([-4712, 1], [d.year, d.yday])

"spanning_heredoc.txt",

"spanning_heredoc_newlines.txt",

# Prism emits a single :on_tstring_content in <<- style heredocs when there

# as if the backslashes are not present.

"heredocs_with_fake_newlines.txt",

]

assert_locations(node.children[-1].locations, [[1, 0, 1, 16], [1, 0, 1, 5], [1, 8, 1, 9], [1, 13, 1, 16]])

end

def test_dot2_locations

node = ast_parse("1..2")

assert_locations(node.children[-1].locations, [[1, 0, 1, 4], [1, 1, 1, 3]])

encodings.each do |e|

assert_raise(TypeError) { e.dup }

assert_raise(TypeError) { e.clone }

end

end

# Create some objects and place it in a WeakMap

wmap = ObjectSpace::WeakMap.new

obj = Object.new

wmap[obj] = nil

end

# Run full GC to collect stats about weak references

GC.start

# Sometimes the WeakMap has a few elements, which might be held on by registers.

assert_operator(GC.latest_gc_info(:weak_references_count), :<=, before_weak_references_count - count + error_tolerance)

assert_operator(GC.latest_gc_info(:retained_weak_references_count), :<=, before_retained_weak_references_count - count + error_tolerance)

end

end

def test_non_string

not_string = Object.new

buf.set_string('a', 0, 0)

assert_predicate buf, :empty?

end

end

assert_equal object_id, obj.object_id

end;

end

end

unless /mswin|mingw/ =~ RUBY_PLATFORM

opts[:rlimit_core] = 0

end

ExecOptions = opts.freeze

# The regexp list that should match the entire stderr output.

args.unshift(env)

test_stdin = ""

assert_in_out_err(args, test_stdin, *tests, encoding: "ASCII-8BIT",

**SEGVTest::ExecOptions, **opt, &block)

def test_segv_loaded_features

bug7402 = '[ruby-core:49573]'

end

def test_segv_setproctitle

}

end

def test_local_variables_with_kwarg

bug11674 = '[ruby-core:71437] [Bug #11674]'

v = with_kwargs_11(v1:1,v2:2,v3:3,v4:4,v5:5,v6:6,v7:7,v8:8,v9:9,v10:10,v11:11)

}

end

def test_leave_param

assert_compiles '5', %q{

def test(n) = n

}, insns: [:opt_ge], call_threshold: 2

end

def test_new_array_empty

assert_compiles '[]', %q{

def test = []

}

end

def test_send_backtrace

backtrace = [

"-e:2:in 'Object#jit_frame1'",

}, call_threshold: 2

end

# tool/ruby_vm/views/*.erb relies on the zjit instructions a) being contiguous and

# b) being reliably ordered after all the other instructions.

def test_instruction_order

path

end

##

# Load a YAML string, the psych 3 way

@cmd.options[:args] = %w[a]

use_ui @ui do

assert_raise Gem::MockGemUi::SystemExitException, @ui.error do

@cmd.execute

end

end

end

@cmd.options[:args] = %w[a]

use_ui @ui do

assert_raise Gem::MockGemUi::SystemExitException, @ui.error do

@cmd.execute

end

end

end

@cmd.options[:args] = %w[a]

use_ui @ui do

assert_raise Gem::MockGemUi::SystemExitException, @ui.error do

@cmd.execute

end

end

end

FileUtils.mv f1_gem, @tempdir

inst = nil

inst = Gem::DependencyInstaller.new

inst.install "f"

end

assert_equal %w[f-1], inst.installed_gems.map(&:full_name)

assert_equal %w[a-1], inst.installed_gems.map(&:full_name)

end

def test_install_minimal_deps

util_setup_gems

@spec = setup_base_spec

@spec.extensions << "extconf.rb"

@spec.files += %w[extconf.rb]

@spec = setup_base_spec

@spec.extensions << "extconf.rb"

@spec.files += %w[extconf.rb]

def test_install_user_extension_dir

@spec = setup_base_spec

@spec.extensions << "extconf.rb"

@spec.files += %w[extconf.rb]

@spec = setup_base_spec

@spec.extensions << "extconf.rb"

io.write <<-RUBY

CONFIG['CC'] = '$(TOUCH) $@ ||'

CONFIG['LDSHARED'] = '$(TOUCH) $@ ||'

$ruby = '#{Gem.ruby}'

RUBY

end

@spec = setup_base_spec

@spec.extensions << "extconf.rb"

rb = File.join("lib", "#{@spec.name}.rb")

@spec.files += [rb]

@spec.extensions << "extconf.rb"

io.write <<-RUBY

CONFIG['CC'] = '$(TOUCH) $@ ||'

CONFIG['LDSHARED'] = '$(TOUCH) $@ ||'

$ruby = '#{Gem.ruby}'

RUBY

end

@spec.require_paths = ["."]

@spec.extensions << "extconf.rb"

# empty depend file for no auto dependencies

@spec.files += %W[depend #{@spec.name}.c].each do |file|

RUBY

end

def test_tcp_socket_one_hostname_resolution_succeeded_at_least

opts = %w[-rsocket -W1]

assert_separately opts, <<~RUBY

#endif

}

void *

rb_nogvl(void *(*func)(void *), void *data1,

rb_unblock_function_t *ubf, void *data2,

bool is_main_thread = vm->ractor.main_thread == th;

int saved_errno = 0;

if (flags & RB_NOGVL_UBF_ASYNC_SAFE) {

vm->ubf_async_safe = 1;

}

if (task) {

if (task->flags & rb_interrupt_exec_flag_new_thread) {

rb_thread_create(task->func, task->data);

(*task->func)(task->data);

}

ruby_xfree(task);

def git(*args)

cmd = ['git', *args].shelljoin

puts "+ #{cmd}"

abort "Failed to run: #{cmd}"

end

end

%r{\Asample/trick[^/]*/},

]

oldrev, newrev, pushref = ARGV

unless dry_run = pushref.empty?

branch = IO.popen(['git', 'rev-parse', '--symbolic', '--abbrev-ref', pushref], &:read).strip

exit

end

edited_files = files.select do |f|

src = File.binread(f) rescue next

trailing0 = false

expandtab0 = false

src.gsub!(/^.*$/).with_index do |line, lineno|

trailing = trailing0 = true if line.sub!(/[ \t]+$/, '')

line

end

end

File.binwrite(f, src)

true

end

msg = [('remove trailing spaces' if trailing),

('append newline at EOF' if eofnewline),

('expand tabs' if expandtab),

].compact

message = "* #{msg.join(', ')}. [ci skip]"

if expandtab

# Assume the directory by these environment variables are safe.

base = [ENV["TMPDIR"], ENV["TMP"], "/tmp"].find do |tmp|

next unless tmp and tmp.size <= 50 and File.directory?(tmp)

#

# Also Rubygems creates its own temporary directory per tests, and

# path contains both temporary names twice, and can exceed path name

# limit very easily.

tmp

end

def assert_in_out_err(args, test_stdin = "", test_stdout = [], test_stderr = [], message = nil,

args = Array(args).dup

args.insert((Hash === args[0] ? 1 : 0), '--disable=gems')

stdout, stderr, status = EnvUtil.invoke_ruby(args, test_stdin, true, true, **opt)

if block_given?

raise "test_stdout ignored, use block only or without block" if test_stdout != []

raise "test_stderr ignored, use block only or without block" if test_stderr != []

end

module_function :timeout

def terminate(pid, signal = :TERM, pgroup = nil, reprieve = 1)

reprieve = apply_timeout_scale(reprieve) if reprieve

pgroup = pid

end

while signal = signals.shift

end

begin

end

def kill

signal = RUBY_PLATFORM =~ /mswin|mingw/ ? :KILL : :SEGV

Process.kill(signal, @pid)

warn "worker #{to_s} does not respond; #{signal} is sent"

parser.on '--repeat-count=NUM', "Number of times to repeat", Integer do |n|

options[:repeat_count] = n

end

end

def _run_anything(type)

@repeat_count = @options[:repeat_count]

super

end

end

[(@repeat_count ? "(#{@@current_repeat_count}/#{@repeat_count}) " : ""), type,

t, @test_count.fdiv(t), @assertion_count.fdiv(t)]

end while @repeat_count && @@current_repeat_count < @repeat_count &&

output.sync = old_sync if sync

assert_not_nil($1, "'done' was not found")

result = Marshal.load($1.chomp.unpack1("m"))

end

end

assert_equal(1,1)

end

end

def test_always_fail

assert_equal(0,1)

end

begin

raise UnknownError, "unknown error"

rescue

end

end

return generic_fields_tbl_;

}

int

{

RUBY_ASSERT(!RB_TYPE_P(obj, T_ICLASS));

RB_VM_LOCKING() {

if (st_lookup(generic_fields_tbl(obj, id, false), (st_data_t)obj, &data)) {

r = 1;

}

}

}

int

{

}

void

rb_mark_generic_ivar(VALUE obj)

{

}

}

if (rb_obj_exivar_p(obj)) {

st_data_t key = (st_data_t)obj, value;

RB_VM_LOCKING() {

}

}

}

VALUE

case T_OBJECT:

fields_hash = ROBJECT_FIELDS_HASH(obj);

break;

default:

RUBY_ASSERT(rb_obj_exivar_p(obj));

break;

}

VALUE value = Qundef;

case T_OBJECT:

fields = ROBJECT_FIELDS(obj);

break;

default:

RUBY_ASSERT(rb_obj_exivar_p(obj));

break;

}

return fields[attr_index];

case T_IMEMO:

// Handled like T_OBJECT

{

shape_id = RBASIC_SHAPE_ID(obj);

if (rb_shape_too_complex_p(shape_id)) {

VALUE val;

if (rb_st_lookup(iv_table, (st_data_t)id, (st_data_t *)&val)) {

return val;

}

RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj));

break;

}

case T_OBJECT:

default:

shape_id = RBASIC_SHAPE_ID(obj);

if (rb_obj_exivar_p(obj)) {

VALUE val;

return val;

}

else {

return undef;

}

}

}

else {

return undef;

VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);

if (fields_obj) {

if (rb_multi_ractor_p()) {

val = rb_ivar_delete(fields_obj, id, undef);

RCLASS_WRITABLE_SET_FIELDS_OBJ(obj, fields_obj);

}

rb_bug("Unreachable");

break;

case T_IMEMO:

break;

case T_OBJECT:

fields = ROBJECT_FIELDS(obj);

break;

default: {

break;

}

}

break;

case T_IMEMO:

break;

case T_OBJECT:

break;

default: {

}

break;

}

return rb_ivar_delete(obj, id, Qnil);

}

static shape_id_t

obj_transition_too_complex(VALUE obj, st_table *table)

{

RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj));

shape_id_t shape_id = rb_shape_transition_complex(obj);

switch (BUILTIN_TYPE(obj)) {

case T_OBJECT:

}

break;

case T_CLASS:

case T_MODULE:

rb_bug("Unreachable");

break;

default:

RBASIC_SET_SHAPE_ID(obj, shape_id);

}

}

return shape_id;

}

obj_transition_too_complex(obj, table);

}

// Copy all object fields, including ivars and internal object_id, etc

shape_id_t

rb_evict_fields_to_hash(VALUE obj)

{

RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj));

st_table *table = st_init_numtable_with_size(RSHAPE_LEN(RBASIC_SHAPE_ID(obj)));

}

}

{

}

}

}

}

}

static void

{

}

}

void

break;

case T_IMEMO:

break;

case T_OBJECT:

break;

default: {

}

}

}

return ST_CONTINUE;

}

switch (BUILTIN_TYPE(itr_data->obj)) {

case T_OBJECT:

RUBY_ASSERT(!rb_shape_obj_too_complex_p(itr_data->obj));

break;

case T_IMEMO:

RUBY_ASSERT(!rb_shape_obj_too_complex_p(itr_data->obj));

break;

default:

}

return itr_data->func(RSHAPE_EDGE_NAME(shape_id), val, itr_data->arg);

}

}

static void

{

struct iv_itr_data itr_data = {

.obj = fields_obj,

shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);

if (rb_shape_too_complex_p(shape_id)) {

}

else {

iterate_over_shapes(shape_id, func, &itr_data);

}

}

void

rb_copy_generic_ivar(VALUE dest, VALUE obj)

{

rb_check_frozen(dest);

return;

}

shape_id_t src_shape_id = rb_obj_shape_id(obj);

goto clear;

if (rb_shape_too_complex_p(src_shape_id)) {

return;

}

st_table *table = rb_st_init_numtable_with_size(src_num_ivs);

rb_obj_copy_ivs_to_hash_table(obj, table);

rb_obj_init_too_complex(dest, table);

return;

}

}

if (!RSHAPE_LEN(dest_shape_id)) {

rb_obj_set_shape_id(dest, dest_shape_id);

return;

}

rb_shape_copy_fields(dest, dest_buf, dest_shape_id, obj, src_buf, src_shape_id);

RB_VM_LOCKING() {

generic_fields_tbl_no_ractor_check(dest);

}

}

return;

void

rb_replace_generic_ivar(VALUE clone, VALUE obj)

{

RB_VM_LOCKING() {

st_data_t fields_tbl, obj_data = (st_data_t)obj;

if (st_delete(generic_fields_tbl_, &obj_data, &fields_tbl)) {

st_insert(generic_fields_tbl_, (st_data_t)clone, fields_tbl);

}

else {

rb_bug("unreachable");

if (SPECIAL_CONST_P(obj)) return;

switch (BUILTIN_TYPE(obj)) {

case T_IMEMO:

}

break;

case T_OBJECT:

IVAR_ACCESSOR_SHOULD_BE_MAIN_RACTOR(0);

VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);

if (fields_obj) {

}

}

break;

default:

if (rb_obj_exivar_p(obj)) {

}

break;

}

case T_OBJECT:

iv_count = ROBJECT_FIELDS_COUNT(obj);

break;

case T_CLASS:

case T_MODULE:

{

return 0;

}

if (rb_shape_obj_too_complex_p(fields_obj)) {

}

}

default:

if (rb_obj_exivar_p(obj)) {

}

}

break;

{

bool existing = true;

const VALUE original_fields_obj = fields_obj;

shape_id_t current_shape_id = RBASIC_SHAPE_ID(fields_obj);

shape_id_t next_shape_id = current_shape_id;

next_shape_id = rb_shape_transition_add_ivar(fields_obj, id);

if (UNLIKELY(rb_shape_too_complex_p(next_shape_id))) {

attr_index_t current_len = RSHAPE_LEN(current_shape_id);

if (current_len) {

RBASIC_SET_SHAPE_ID(fields_obj, next_shape_id);

}

goto too_complex;

// We allocate a new fields_obj even when concurrency isn't a concern

// so that we're embedded as long as possible.

if (original_fields_obj) {

}

}

RUBY_ASSERT(index == (RSHAPE_LEN(next_shape_id) - 1));

}

RB_OBJ_WRITE(fields_obj, &fields[index], val);

if (!existing) {

too_complex:

{

existing = st_insert(table, (st_data_t)id, (st_data_t)val);

RB_OBJ_WRITTEN(fields_obj, Qundef, val);

if (new_fields_obj != original_fields_obj) {

RCLASS_WRITABLE_SET_FIELDS_OBJ(obj, new_fields_obj);

}

return existing;

}

#include "shape.h"

void rb_copy_complex_ivars(VALUE dest, VALUE obj, shape_id_t src_shape_id, st_table *fields_table);

void rb_free_rb_global_tbl(void);

if (ptr) {

rb_vm_t *vm = ptr;

vm->mark_object_ary = rb_gc_location(vm->mark_object_ary);

vm->load_path = rb_gc_location(vm->load_path);

vm->load_path_snapshot = rb_gc_location(vm->load_path_snapshot);

rb_gc_mark_maybe(*list->varptr);

}

if (vm->main_namespace) {

rb_namespace_entry_mark((void *)vm->main_namespace);

}

void

rb_ec_clear_vm_stack(rb_execution_context_t *ec)

{

ec->cfp = NULL;

}

static void

if (!fields_obj) {

return default_value;

}

break;

}

default:

if (rb_obj_exivar_p(obj)) {

}

else {

return default_value;

switch (BUILTIN_TYPE(obj)) {

case T_CLASS:

case T_MODULE:

break;

case T_OBJECT:

break;

default: {

}

break;

}

{

shape_id_t shape_id = RBASIC_SHAPE_ID(obj);

// Cache hit case

if (shape_id == dest_shape_id) {

return Qundef;

}

if (shape_id != dest_shape_id) {

RBASIC_SET_SHAPE_ID(obj, dest_shape_id);

}

RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);

}

}

static VALUE

vm_concat_array(VALUE ary1, VALUE ary2st)

{

pub const RUBY_FL_UNUSED6: ruby_fl_type = 64;

pub const RUBY_FL_FINALIZE: ruby_fl_type = 128;

pub const RUBY_FL_TAINT: ruby_fl_type = 0;

pub const RUBY_FL_SHAREABLE: ruby_fl_type = 256;

pub const RUBY_FL_UNTRUSTED: ruby_fl_type = 0;

pub const RUBY_FL_UNUSED9: ruby_fl_type = 512;

pub const RUBY_FL_FREEZE: ruby_fl_type = 2048;

pub const RUBY_FL_USER0: ruby_fl_type = 4096;

pub const RUBY_FL_USER1: ruby_fl_type = 8192;

pub const imemo_callinfo: imemo_type = 11;

pub const imemo_callcache: imemo_type = 12;

pub const imemo_constcache: imemo_type = 13;

pub type imemo_type = u32;

#[repr(C)]

#[derive(Debug, Copy, Clone)]

use crate::{asm::CodeBlock, cruby::*, options::debug, virtualmem::CodePtr};

use crate::invariants::{iseq_escapes_ep, track_no_ep_escape_assumption};

use crate::backend::lir::{self, asm_comment, Assembler, Opnd, Target, CFP, C_ARG_OPNDS, C_RET_OPND, EC, SP};

use crate::hir::{Const, FrameState, Function, Insn, InsnId};

use crate::hir_type::{types::Fixnum, Type};

use crate::options::get_option;

Insn::NewArray { elements, state } => gen_new_array(jit, asm, elements, &function.frame_state(*state)),

Insn::NewRange { low, high, flag, state } => gen_new_range(asm, opnd!(low), opnd!(high), *flag, &function.frame_state(*state)),

Insn::ArrayDup { val, state } => gen_array_dup(asm, opnd!(val), &function.frame_state(*state)),

Insn::Param { idx } => unreachable!("block.insns should not have Insn::Param({idx})"),

Insn::Snapshot { .. } => return Some(()), // we don't need to do anything for this instruction at the moment

Insn::Jump(branch) => return gen_jump(jit, asm, branch),

Insn::GetIvar { self_val, id, state: _ } => gen_getivar(asm, opnd!(self_val), *id),

Insn::SetGlobal { id, val, state: _ } => gen_setglobal(asm, *id, opnd!(val)),

Insn::GetGlobal { id, state: _ } => gen_getglobal(asm, *id),

Insn::SetIvar { self_val, id, val, state: _ } => return gen_setivar(asm, opnd!(self_val), *id, opnd!(val)),

Insn::SideExit { state } => return gen_side_exit(jit, asm, &function.frame_state(*state)),

_ => {

debug!("ZJIT: gen_function: unexpected insn {:?}", insn);

return None;

Some(())

}

/// Lowering for [`Insn::CCall`]. This is a low-level raw call that doesn't know

/// anything about the callee, so handling for e.g. GC safety is dealt with elsewhere.

fn gen_ccall(jit: &mut JITState, asm: &mut Assembler, cfun: *const u8, args: &[InsnId]) -> Option<lir::Opnd> {

Some(())

}

/// Compile an interpreter entry block to be inserted into an ISEQ

fn gen_entry_prologue(asm: &mut Assembler, iseq: IseqPtr) {

asm_comment!(asm, "ZJIT entry point: {}", iseq_get_location(iseq, 0));

Some(ret)

}

/// Compile an array duplication instruction

fn gen_array_dup(

asm: &mut Assembler,

pub fn rb_str_setbyte(str: VALUE, index: VALUE, value: VALUE) -> VALUE;

pub fn rb_vm_splat_array(flag: VALUE, ary: VALUE) -> VALUE;

pub fn rb_vm_concat_array(ary1: VALUE, ary2st: VALUE) -> VALUE;

pub fn rb_vm_concat_to_array(ary1: VALUE, ary2st: VALUE) -> VALUE;

pub fn rb_vm_defined(

ec: EcPtr,

pub use rb_vm_ci_kwarg as vm_ci_kwarg;

pub use rb_METHOD_ENTRY_VISI as METHOD_ENTRY_VISI;

pub use rb_RCLASS_ORIGIN as RCLASS_ORIGIN;

/// Helper so we can get a Rust string for insn_name()

pub fn insn_name(opcode: usize) -> String {

pub const RUBY_FL_UNUSED6: ruby_fl_type = 64;

pub const RUBY_FL_FINALIZE: ruby_fl_type = 128;

pub const RUBY_FL_TAINT: ruby_fl_type = 0;

pub const RUBY_FL_SHAREABLE: ruby_fl_type = 256;

pub const RUBY_FL_UNTRUSTED: ruby_fl_type = 0;

pub const RUBY_FL_UNUSED9: ruby_fl_type = 512;

pub const RUBY_FL_FREEZE: ruby_fl_type = 2048;

pub const RUBY_FL_USER0: ruby_fl_type = 4096;

pub const RUBY_FL_USER1: ruby_fl_type = 8192;

pub const imemo_callinfo: imemo_type = 11;

pub const imemo_callcache: imemo_type = 12;

pub const imemo_constcache: imemo_type = 13;

pub type imemo_type = u32;

pub const METHOD_VISI_UNDEF: rb_method_visibility_t = 0;

pub const METHOD_VISI_PUBLIC: rb_method_visibility_t = 1;

}

}

/// Print adaptor for [`Invariant`]. See [`PtrPrintMap`].

pub struct InvariantPrinter<'a> {

inner: Invariant,

write!(f, "BOPRedefined(")?;

match klass {

INTEGER_REDEFINED_OP_FLAG => write!(f, "INTEGER_REDEFINED_OP_FLAG")?,

ARRAY_REDEFINED_OP_FLAG => write!(f, "ARRAY_REDEFINED_OP_FLAG")?,

_ => write!(f, "{klass}")?,

}

write!(f, ", ")?;

BOP_LE => write!(f, "BOP_LE")?,

BOP_GT => write!(f, "BOP_GT")?,

BOP_GE => write!(f, "BOP_GE")?,

BOP_MAX => write!(f, "BOP_MAX")?,

_ => write!(f, "{bop}")?,

}

/// SSA block parameter. Also used for function parameters in the function's entry block.

Param { idx: usize },

StringIntern { val: InsnId },

/// Call `to_a` on `val` if the method is defined, or make a new array `[val]` otherwise.

ToArray { val: InsnId, state: InsnId },

/// Call `to_a` on `val` if the method is defined, or make a new array `[val]` otherwise. If we

/// Return C `true` if `val` is `Qnil`, else `false`.

IsNil { val: InsnId },

Defined { op_type: usize, obj: VALUE, pushval: VALUE, v: InsnId },

/// Get a global variable named `id`

GetGlobal { id: ID, state: InsnId },

Insn::ArraySet { array, idx, val } => { write!(f, "ArraySet {array}, {idx}, {val}") }

Insn::ArrayDup { val, .. } => { write!(f, "ArrayDup {val}") }

Insn::HashDup { val, .. } => { write!(f, "HashDup {val}") }

Insn::Test { val } => { write!(f, "Test {val}") }

Insn::IsNil { val } => { write!(f, "IsNil {val}") }

Insn::Jump(target) => { write!(f, "Jump {target}") }

Insn::GuardType { val, guard_type, .. } => { write!(f, "GuardType {val}, {}", guard_type.print(self.ptr_map)) },

Insn::GuardBitEquals { val, expected, .. } => { write!(f, "GuardBitEquals {val}, {}", expected.print(self.ptr_map)) },

Insn::PatchPoint(invariant) => { write!(f, "PatchPoint {}", invariant.print(self.ptr_map)) },

Insn::CCall { cfun, args, name, return_type: _, elidable: _ } => {

write!(f, "CCall {}@{:p}", name.contents_lossy(), self.ptr_map.map_ptr(cfun))?;

for arg in args {

Insn::ArrayExtend { left, right, .. } => write!(f, "ArrayExtend {left}, {right}"),

Insn::ArrayPush { array, val, .. } => write!(f, "ArrayPush {array}, {val}"),

Insn::SideExit { .. } => write!(f, "SideExit"),

insn => { write!(f, "{insn:?}") }

}

}

}

},

Return { val } => Return { val: find!(*val) },

StringIntern { val } => StringIntern { val: find!(*val) },

Test { val } => Test { val: find!(*val) },

&IsNil { val } => IsNil { val: find!(val) },

FixnumGe { left, right } => FixnumGe { left: find!(*left), right: find!(*right) },

FixnumLt { left, right } => FixnumLt { left: find!(*left), right: find!(*right) },

FixnumLe { left, right } => FixnumLe { left: find!(*left), right: find!(*right) },

SendWithoutBlock { self_val, call_info, cd, args, state } => SendWithoutBlock {

self_val: find!(*self_val),

call_info: call_info.clone(),

Insn::FixnumLe { .. } => types::BoolExact,

Insn::FixnumGt { .. } => types::BoolExact,

Insn::FixnumGe { .. } => types::BoolExact,

Insn::SendWithoutBlock { .. } => types::BasicObject,

Insn::SendWithoutBlockDirect { .. } => types::BasicObject,

Insn::Send { .. } => types::BasicObject,

}

}

/// Rewrite SendWithoutBlock opcodes into SendWithoutBlockDirect opcodes if we know the target

/// ISEQ statically. This removes run-time method lookups and opens the door for inlining.

fn optimize_direct_sends(&mut self) {

self.try_rewrite_fixnum_op(block, insn_id, &|left, right| Insn::FixnumGt { left, right }, BOP_GT, self_val, args[0], state),

Insn::SendWithoutBlock { self_val, call_info: CallInfo { method_name }, args, state, .. } if method_name == ">=" && args.len() == 1 =>

self.try_rewrite_fixnum_op(block, insn_id, &|left, right| Insn::FixnumGe { left, right }, BOP_GE, self_val, args[0], state),

Insn::SendWithoutBlock { mut self_val, call_info, cd, args, state } => {

let frame_state = self.frame_state(state);

let (klass, guard_equal_to) = if let Some(klass) = self.type_of(self_val).runtime_exact_ruby_class() {

let send_direct = self.push_insn(block, Insn::SendWithoutBlockDirect { self_val, call_info, cd, cme, iseq, args, state });

self.make_equal_to(insn_id, send_direct);

}

let idlist: *const ID = unsafe { (*ic).segments };

let ice = unsafe { (*ic).entry };

if ice.is_null() {

if necessary[insn_id.0] { continue; }

necessary[insn_id.0] = true;

match self.find(insn_id) {

{}

Insn::ArrayMax { elements, state }

| Insn::NewArray { elements, state } => {

worklist.extend(elements);

worklist.push_back(high);

worklist.push_back(state);

}

| Insn::StringIntern { val }

| Insn::Return { val }

| Insn::Defined { v: val, .. }

YARVINSN_nop => {},

YARVINSN_putnil => { state.stack_push(fun.push_insn(block, Insn::Const { val: Const::Value(Qnil) })); },

YARVINSN_putobject => { state.stack_push(fun.push_insn(block, Insn::Const { val: Const::Value(get_arg(pc, 0)) })); },

let val = fun.push_insn(block, Insn::Const { val: Const::Value(get_arg(pc, 0)) });

state.stack_push(insn_id);

}

YARVINSN_putself => { state.stack_push(self_param); }

}

YARVINSN_opt_getconstant_path => {

let ic = get_arg(pc, 0).as_ptr();

}

YARVINSN_branchunless => {

let offset = get_arg(pc, 0).as_i64();

let send = fun.push_insn(block, Insn::SendWithoutBlock { self_val: recv, call_info: CallInfo { method_name }, cd, args, state: exit_id });

state.stack_push(send);

}

YARVINSN_leave => {

fun.push_insn(block, Insn::Return { val: state.stack_pop()? });

}

#[test]

fn test_setlocal_getlocal() {

eval("

def test

assert_method_hir("test", expect![[r#"

fn test:

bb0(v0:BasicObject, v1:BasicObject):

SideExit

"#]]);

}

assert_method_hir_with_opcode("test", YARVINSN_opt_new, expect![[r#"

fn test:

bb0(v0:BasicObject):

"#]]);

}

}

#[test]

fn test_branchnil() {

eval("

def test(x) = x&.itself

assert_optimized_method_hir("test", expect![[r#"

fn test:

bb0(v0:BasicObject):

"#]]);

}

PatchPoint SingleRactorMode

PatchPoint StableConstantNames(0x1000, M)

PatchPoint MethodRedefined(Module@0x1008, name@0x1010)

"#]]);

}

assert_optimized_method_hir("test", expect![[r#"

fn test:

bb0(v0:BasicObject):

"#]]);

}

assert_optimized_method_hir("test", expect![[r#"

fn test:

bb0(v0:BasicObject):

"#]]);

}

bb0(v0:BasicObject):

PatchPoint SingleRactorMode

PatchPoint StableConstantNames(0x1000, Kernel)

"#]]);

}

bb0(v0:BasicObject):

PatchPoint SingleRactorMode

PatchPoint StableConstantNames(0x1000, Foo::Bar::C)

"#]]);

}

bb0(v0:BasicObject):

PatchPoint SingleRactorMode

PatchPoint StableConstantNames(0x1000, C)

"#]]);

}

bb0(v0:BasicObject):

PatchPoint SingleRactorMode

PatchPoint StableConstantNames(0x1000, C)

"#]]);

}

Return v2

"#]]);

}

}