- 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

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)

# 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);

}

# 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)) {

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;

}

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");

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;

}

/* 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

# 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"

RARRAY_ASET(sym_proc_cache, index, procval);

return RB_GC_GUARD(procval);

return sym_proc_new(rb_cProc, sym);

}

}

} 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);

}

}

#endif

VALUE klass;

klass = CLASS_OF(obj);

}

else {

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

"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",

]

encodings.each do |e|

assert_raise(TypeError) { e.dup }

assert_raise(TypeError) { e.clone }

end

end

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

assert_predicate buf, :empty?

end

end

}, 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'",

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|

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);

if File.fnmatch?("*.[ch]", f, File::FNM_PATHNAME) &&

!DIFFERENT_STYLE_FILES.any? {|pat| File.fnmatch?(pat, f, File::FNM_PATHNAME)}

src.gsub!(/^\w+\([^(\n)]*?\)\K[ \t]*(?=\{$)/, "\n")

src.gsub!(/^([ \t]*)\}\K[ \t]*(?=else\b)/, "\n" '\1')

src.gsub!(/^[ \t]*\}\n\K\n+(?=[ \t]*else\b)/, '')

end

if trailing0 or eofnewline0 or expandtab0 or indent0

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;

}

}

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;

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 (!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);

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)]

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)),

Insn::PutSpecialObject { value_type } => gen_putspecialobject(asm, *value_type),

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> {

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;

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}")?,

}

/// 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::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 {

}

}

/// 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::PutSpecialObject { .. } =>

{}

Insn::ArrayMax { elements, state }

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

worklist.extend(elements);

}

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_with_opcode("test", YARVINSN_opt_new, expect![[r#"

fn test:

bb0(v0:BasicObject):

"#]]);

}

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

"#]]);

}

}