+ value: ${{ steps.global.outputs.stdout_report_path }}

+ value: ${{ steps.global.outputs.stderr_report_path }}

+ echo stdout_report_path="launchable_stdout.log" >> $GITHUB_OUTPUT

+ echo stderr_report_path="launchable_stderr.log" >> $GITHUB_OUTPUT

+ echo test_spec_enabled=true >> $GITHUB_OUTPUT

+

+ echo launchable_setup_dir=$(pwd) >> $GITHUB_OUTPUT

+ - name: make test-spec report directory in build directory

+ shell: bash

+ working-directory: ${{ inputs.builddir }}

+ run: mkdir "${test_spec_report_dir}"

+ if: ${{ steps.setup-launchable.outputs.test_spec_enabled == 'true' }}

+ env:

+ test_spec_report_dir: ${{ steps.global.outputs.test_spec_report_dir }}

+

+ working-directory: ${{ inputs.builddir }}

+ raw "${test_all_report_file}" || true; \

+ raw "${btest_report_file}" || true; \

+ raw ${test_spec_report_dir}/* || true; \

+ if: ${{ always() && steps.setup-launchable.outcome == 'success' }}

+ test_all_report_file: ${{ steps.global.outputs.test_all_report_file }}

+ btest_report_file: ${{ steps.global.outputs.btest_report_file }}

+ test_spec_report_dir: ${{ steps.global.outputs.test_spec_report_dir }}

+ stdout_report_path: ${{ steps.global.outputs.stdout_report_path }}

+ stderr_report_path: ${{ steps.global.outputs.stderr_report_path }}

+ LAUNCHABLE_SETUP_DIR: ${{ steps.setup-launchable.outputs.launchable_setup_dir }}

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ token: ${{ secrets.MATZBOT_AUTO_REQUEST_REVIEW_TOKEN }}

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ token: ${{ (github.repository == 'ruby/ruby' && !startsWith(github.event_name, 'pull')) && secrets.MATZBOT_AUTO_UPDATE_TOKEN || secrets.GITHUB_TOKEN }}

+ # Skip overwriting MATZBOT_AUTO_UPDATE_TOKEN

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ token: ${{ (github.repository == 'ruby/ruby' && !startsWith(github.event_name, 'pull')) && secrets.MATZBOT_AUTO_UPDATE_TOKEN || secrets.GITHUB_TOKEN }}

+ # Skip overwriting MATZBOT_AUTO_UPDATE_TOKEN

+ token: ${{ (github.repository == 'ruby/ruby' && !startsWith(github.event_name, 'pull')) && secrets.MATZBOT_AUTO_UPDATE_TOKEN || secrets.GITHUB_TOKEN }}

+ # Skip overwriting MATZBOT_AUTO_UPDATE_TOKEN

+ uses: dependabot/fetch-metadata@08eff52bf64351f401fb50d4972fa95b9f2c2d1b # v2.4.0

+ GITHUB_TOKEN: ${{ secrets.MATZBOT_DEPENDABOT_MERGE_TOKEN }}

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ GITHUB_TOKEN: ${{ secrets.MATZBOT_AUTO_UPDATE_TOKEN }}

+name: Scorecard supply-chain security

+ - cron: '39 3 * * 5'

+ name: Scorecard analysis

+ # `publish_results: true` only works when run from the default branch. conditional can be removed if disabled.

+ if: github.event.repository.default_branch == github.ref_name || github.event_name == 'pull_request'

+ - name: "Checkout code"

+ - name: "Run analysis"

+ uses: ossf/scorecard-action@f2ea147fec3c2f0d459703eba7405b5e9bcd8c8f # v2.4.2

+ # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:

+ # - you are installing Scorecard on a *private* repository

+ # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action?tab=readme-ov-file#authentication-with-fine-grained-pat-optional.

+ # repo_token: ${{ secrets.SCORECARD_TOKEN }}

+ # (Optional) Uncomment file_mode if you have a .gitattributes with files marked export-ignore

+ # file_mode: git

+

+ - name: "Upload artifact"

+ uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2

+ with:

+ name: SARIF file

+ path: results.sarif

+ retention-days: 5

+ # Upload the results to GitHub's code scanning dashboard (optional).

+ # Commenting out will disable upload of results to your repo's Code Scanning dashboard

+ - name: "Upload to code-scanning"

+ uses: github/codeql-action/upload-sarif@v3

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2

+ - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ runs-on: windows-2025

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+ - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

+ - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

+ - uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0

+* net-imap 0.5.9

+net-imap 0.5.9 https://github.com/ruby/net-imap

+ git('log', '--format=%H', '-1', @oldrev, out: IO::NULL, err: [:child, :out]) or

+ git('fetch', '--depth=1', 'origin', @oldrev)

+ git('log', '--format=%H', '-1', "#@newrev~99", out: IO::NULL, err: [:child, :out]) or

+ git('fetch', '--depth=100', 'origin', @newrev)

+ def git(*args, **opts)

+ ret = with_clean_env { system('git', *args, **opts) }

+ unless ret or opts[:err]

+ ret

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

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

+ // Distinct from `SendWithoutBlock` with `mid:to_s` because does not have a patch point for String to_s being redefined

+ ObjToString { val: InsnId, call_info: CallInfo, cd: *const rb_call_data, state: InsnId },

+

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

+ ObjToString { val, call_info, cd, state } => ObjToString {

+ val: find!(*val),

+ call_info: call_info.clone(),

+ cd: *cd,

+ state: *state,

+ },

+ Insn::ObjToString { .. } => types::BasicObject,

+ Insn::ObjToString { val, call_info, cd, state, .. } => {

+ if self.is_a(val, types::StringExact) {

+ // behaves differently from `SendWithoutBlock` with `mid:to_s` because ObjToString should not have a patch point for String to_s being redefined

+ self.make_equal_to(insn_id, val);

+ } else {

+ let replacement = self.push_insn(block, Insn::SendWithoutBlock { self_val: val, call_info, cd, args: vec![], state });

+ self.make_equal_to(insn_id, replacement)

+ }

+ }

+ Insn::ObjToString { val, state, .. } => {

+ worklist.push_back(val);

+ worklist.push_back(state);

+ }

+ fn absorb_dst_block(&mut self, num_in_edges: &Vec<u32>, block: BlockId) -> bool {

+ let Some(terminator_id) = self.blocks[block.0].insns.last()

+ else { return false };

+ let Insn::Jump(BranchEdge { target, args }) = self.find(*terminator_id)

+ else { return false };

+ if target == block {

+ // Can't absorb self

+ return false;

+ }

+ if num_in_edges[target.0] != 1 {

+ // Can't absorb block if it's the target of more than one branch

+ return false;

+ }

+ // Link up params with block args

+ let params = std::mem::take(&mut self.blocks[target.0].params);

+ assert_eq!(args.len(), params.len());

+ for (arg, param) in args.iter().zip(params) {

+ self.make_equal_to(param, *arg);

+ }

+ // Remove branch instruction

+ self.blocks[block.0].insns.pop();

+ // Move target instructions into block

+ let target_insns = std::mem::take(&mut self.blocks[target.0].insns);

+ self.blocks[block.0].insns.extend(target_insns);

+ true

+ }

+

+ /// Clean up linked lists of blocks A -> B -> C into A (with B's and C's instructions).

+ fn clean_cfg(&mut self) {

+ // num_in_edges is invariant throughout cleaning the CFG:

+ // * we don't allocate new blocks

+ // * blocks that get absorbed are not in RPO anymore

+ // * blocks pointed to by blocks that get absorbed retain the same number of in-edges

+ let mut num_in_edges = vec![0; self.blocks.len()];

+ for block in self.rpo() {

+ for &insn in &self.blocks[block.0].insns {

+ if let Insn::IfTrue { target, .. } | Insn::IfFalse { target, .. } | Insn::Jump(target) = self.find(insn) {

+ num_in_edges[target.target.0] += 1;

+ }

+ }

+ }

+ let mut changed = false;

+ loop {

+ let mut iter_changed = false;

+ for block in self.rpo() {

+ // Ignore transient empty blocks

+ if self.blocks[block.0].insns.is_empty() { continue; }

+ loop {

+ let absorbed = self.absorb_dst_block(&num_in_edges, block);

+ if !absorbed { break; }

+ iter_changed = true;

+ }

+ }

+ if !iter_changed { break; }

+ changed = true;

+ }

+ if changed {

+ self.infer_types();

+ }

+ }

+

+ self.clean_cfg();

+ YARVINSN_objtostring => {

+ let cd: *const rb_call_data = get_arg(pc, 0).as_ptr();

+ let call_info = unsafe { rb_get_call_data_ci(cd) };

+

+ if unknown_call_type(unsafe { rb_vm_ci_flag(call_info) }) {

+ assert!(false, "objtostring should not have unknown call type");

+ }

+ let argc = unsafe { vm_ci_argc((*cd).ci) };

+ assert_eq!(0, argc, "objtostring should not have args");

+

+ let method_name: String = unsafe {

+ let mid = rb_vm_ci_mid(call_info);

+ mid.contents_lossy().into_owned()

+ };

+

+ let recv = state.stack_pop()?;

+ let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });

+ let objtostring = fun.push_insn(block, Insn::ObjToString { val: recv, call_info: CallInfo { method_name }, cd, state: exit_id });

+ state.stack_push(objtostring)

+ }

+

+ #[test]

+ fn test_objtostring() {

+ eval("

+ def test = \"#{1}\"

+ ");

+ assert_method_hir_with_opcode("test", YARVINSN_objtostring, expect![[r#"

+ fn test:

+ bb0(v0:BasicObject):

+ v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))

+ v3:Fixnum[1] = Const Value(1)

+ v5:BasicObject = ObjToString v3

+ SideExit

+ "#]]);

+ }

+ v11:BasicObject = SendWithoutBlock v20, :new

+ Return v11

+ v13:BasicObject = SendWithoutBlock v22, :new, v5

+ Return v13

+

+ #[test]

+ fn test_objtostring_string() {

+ eval(r##"

+ def test = "#{('foo')}"

+ "##);

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

+ fn test:

+ bb0(v0:BasicObject):

+ v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))

+ v3:StringExact[VALUE(0x1008)] = Const Value(VALUE(0x1008))

+ v4:StringExact = StringCopy v3

+ SideExit

+ "#]]);

+ }

+

+ #[test]

+ fn test_objtostring_with_non_string() {

+ eval(r##"

+ def test = "#{1}"

+ "##);

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

+ fn test:

+ bb0(v0:BasicObject):

+ v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))

+ v3:Fixnum[1] = Const Value(1)

+ v8:BasicObject = SendWithoutBlock v3, :to_s

+ SideExit

+ "#]]);

+ }