[pull] master from ruby:master

encoding.c

@@ -1367,7 +1367,7 @@ enc_names_i(st_data_t name, st_data_t idx, st_data_t args)
     VALUE *arg = (VALUE *)args;
 
     if ((int)idx == (int)arg[0]) {
-        VALUE str = rb_enc_interned_str_cstr((char *)name, rb_usascii_encoding());
+        VALUE str = rb_interned_str_cstr((char *)name);
         rb_ary_push(arg[1], str);
     }
     return ST_CONTINUE;
@@ -1873,7 +1873,7 @@ static int
 rb_enc_name_list_i(st_data_t name, st_data_t idx, st_data_t arg)
 {
     VALUE ary = (VALUE)arg;
-    VALUE str = rb_enc_interned_str_cstr((char *)name, rb_usascii_encoding());
+    VALUE str = rb_interned_str_cstr((char *)name);
     rb_ary_push(ary, str);
     return ST_CONTINUE;
 }
@@ -1921,7 +1921,7 @@ rb_enc_aliases_enc_i(st_data_t name, st_data_t orig, st_data_t arg)
         str = rb_fstring_cstr(rb_enc_name(enc));
         rb_ary_store(ary, idx, str);
     }
-    key = rb_enc_interned_str_cstr((char *)name, rb_usascii_encoding());
+    key = rb_interned_str_cstr((char *)name);
     rb_hash_aset(aliases, key, str);
     return ST_CONTINUE;
 }

ext/io/console/console.c

@@ -84,9 +84,9 @@ getattr(int fd, conmode *t)
 static ID id_getc, id_close;
 static ID id_gets, id_flush, id_chomp_bang;
 
-#ifndef HAVE_RB_ENC_INTERNED_STR_CSTR
+#ifndef HAVE_RB_INTERNED_STR_CSTR
 # define rb_str_to_interned_str(str) rb_str_freeze(str)
-# define rb_enc_interned_str_cstr(str, enc) rb_str_freeze(rb_usascii_str_new_cstr(str))
+# define rb_interned_str_cstr(str) rb_str_freeze(rb_usascii_str_new_cstr(str))
 #endif
 
 #if defined HAVE_RUBY_FIBER_SCHEDULER_H
@@ -1897,7 +1897,7 @@ console_ttyname(VALUE io)
 	size_t size = sizeof(termname);
 	int e;
 	if (ttyname_r(fd, tn, size) == 0)
-	    return rb_enc_interned_str_cstr(tn, rb_usascii_encoding());
+	    return rb_interned_str_cstr(tn);
 	if ((e = errno) == ERANGE) {
 	    VALUE s = rb_str_new(0, size);
 	    while (1) {
@@ -1921,7 +1921,7 @@ console_ttyname(VALUE io)
 	    int e = errno;
 	    rb_syserr_fail_str(e, rb_sprintf("ttyname(%d)", fd));
 	}
-	return rb_enc_interned_str_cstr(tn, rb_usascii_encoding());
+	return rb_interned_str_cstr(tn);
     }
 # else
 #   error No ttyname function

ext/io/console/extconf.rb

@@ -9,7 +9,7 @@
 have_func("rb_syserr_new_str(0, Qnil)") or
   abort
 
-have_func("rb_enc_interned_str_cstr")
+have_func("rb_interned_str_cstr")
 have_func("rb_io_path", "ruby/io.h")
 have_func("rb_io_descriptor", "ruby/io.h")
 have_func("rb_io_get_write_io", "ruby/io.h")

gc/default/default.c

@@ -9582,7 +9582,7 @@ rb_gc_impl_init(void)
         VALUE opts;
         /* \GC build options */
         rb_define_const(rb_mGC, "OPTS", opts = rb_ary_new());
-#define OPT(o) if (o) rb_ary_push(opts, rb_enc_interned_str(#o, sizeof(#o) - 1, rb_usascii_encoding()))
+#define OPT(o) if (o) rb_ary_push(opts, rb_interned_str(#o, sizeof(#o) - 1))
         OPT(GC_DEBUG);
         OPT(USE_RGENGC);
         OPT(RGENGC_DEBUG);

include/ruby/internal/intern/string.h

@@ -444,8 +444,8 @@ VALUE rb_str_to_interned_str(VALUE str);
  *                           terminating NUL character.
  * @exception  rb_eArgError  `len` is negative.
  * @return     A  found or  created instance  of ::rb_cString,  of `len`  bytes
- *             length, of  "binary" encoding,  whose contents are  identical to
- *             that of `ptr`.
+ *             length,  of US-ASCII  or "binary"  encoding, whose  contents are
+ *             identical to that of `ptr`.
  * @pre        At  least  `len` bytes  of  continuous  memory region  shall  be
  *             accessible via `ptr`.
  */

jit.c

@@ -191,6 +191,14 @@ rb_jit_get_proc_ptr(VALUE procv)
     return proc;
 }
 
+VALUE
+rb_optimized_call(VALUE *recv, rb_execution_context_t *ec, int argc, VALUE *argv, int kw_splat, VALUE block_handler)
+{
+    rb_proc_t *proc;
+    GetProcPtr(recv, proc);
+    return rb_vm_invoke_proc(ec, proc, argc, argv, kw_splat, block_handler);
+}
+
 unsigned int
 rb_jit_iseq_builtin_attrs(const rb_iseq_t *iseq)
 {

string.c

@@ -12709,7 +12709,15 @@ VALUE
 rb_interned_str(const char *ptr, long len)
 {
     struct RString fake_str = {RBASIC_INIT};
-    return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_ASCII_8BIT), true, false);
+    int encidx = ENCINDEX_US_ASCII;
+    int coderange = ENC_CODERANGE_7BIT;
+    if (len > 0 && search_nonascii(ptr, ptr + len)) {
+        encidx = ENCINDEX_ASCII_8BIT;
+        coderange = ENC_CODERANGE_VALID;
+    }
+    VALUE str = setup_fake_str(&fake_str, ptr, len, encidx);
+    ENC_CODERANGE_SET(str, coderange);
+    return register_fstring(str, true, false);
 }
 
 VALUE

test/-ext-/string/test_interned_str.rb

@@ -9,4 +9,9 @@ def test_interned_str
     src << "b" * 20
     assert_equal "a" * 20, interned_str
   end
+
+  def test_interned_str_encoding
+    src = :ascii.name
+    assert_equal Encoding::US_ASCII, Bug::String.rb_interned_str_dup(src).encoding
+  end
 end

test/ruby/test_zjit.rb

@@ -470,6 +470,74 @@ def test(&block)
     }, insns: [:getblockparamproxy]
   end
 
+  def test_optimized_method_call_proc_call
+    assert_compiles '2', %q{
+      p = proc { |x| x * 2 }
+      def test(p)
+        p.call(1)
+      end
+      test(p)
+      test(p)
+    }, call_threshold: 2, insns: [:opt_send_without_block]
+  end
+
+  def test_optimized_method_call_proc_aref
+    assert_compiles '4', %q{
+      p = proc { |x| x * 2 }
+      def test(p)
+        p[2]
+      end
+      test(p)
+      test(p)
+    }, call_threshold: 2, insns: [:opt_aref]
+  end
+
+  def test_optimized_method_call_proc_yield
+    assert_compiles '6', %q{
+      p = proc { |x| x * 2 }
+      def test(p)
+        p.yield(3)
+      end
+      test(p)
+      test(p)
+    }, call_threshold: 2, insns: [:opt_send_without_block]
+  end
+
+  def test_optimized_method_call_proc_kw_splat
+    assert_compiles '3', %q{
+      p = proc { |**kw| kw[:a] + kw[:b] }
+      def test(p, h)
+        p.call(**h)
+      end
+      h = { a: 1, b: 2 }
+      test(p, h)
+      test(p, h)
+    }, call_threshold: 2, insns: [:opt_send_without_block]
+  end
+
+  def test_optimized_method_call_proc_call_splat
+    assert_compiles '43', %q{
+      p = proc { |x| x + 1 }
+      def test(p)
+        ary = [42]
+        p.call(*ary)
+      end
+      test(p)
+      test(p)
+    }, call_threshold: 2
+  end
+
+  def test_optimized_method_call_proc_call_kwarg
+    assert_compiles '1', %q{
+      p = proc { |a:| a }
+      def test(p)
+        p.call(a: 1)
+      end
+      test(p)
+      test(p)
+    }, call_threshold: 2
+  end
+
   def test_call_a_forwardable_method
     assert_runs '[]', %q{
       def test_root = forwardable

yjit.c

@@ -223,14 +223,6 @@ typedef struct rb_iseq_param_keyword rb_seq_param_keyword_struct;
 
 ID rb_get_symbol_id(VALUE namep);
 
-VALUE
-rb_optimized_call(VALUE *recv, rb_execution_context_t *ec, int argc, VALUE *argv, int kw_splat, VALUE block_handler)
-{
-    rb_proc_t *proc;
-    GetProcPtr(recv, proc);
-    return rb_vm_invoke_proc(ec, proc, argc, argv, kw_splat, block_handler);
-}
-
 // If true, the iseq has only opt_invokebuiltin_delegate(_leave) and leave insns.
 static bool
 invokebuiltin_delegate_leave_p(const rb_iseq_t *iseq)

zjit/src/codegen.rs

@@ -404,6 +404,7 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         Insn::SendWithoutBlockDirect { cme, iseq, recv, args, state, .. } => gen_send_iseq_direct(cb, jit, asm, *cme, *iseq, opnd!(recv), opnds!(args), &function.frame_state(*state), None),
         &Insn::InvokeSuper { cd, blockiseq, state, reason, .. } => gen_invokesuper(jit, asm, cd, blockiseq, &function.frame_state(state), reason),
         &Insn::InvokeBlock { cd, state, reason, .. } => gen_invokeblock(jit, asm, cd, &function.frame_state(state), reason),
+        Insn::InvokeProc { recv, args, state, kw_splat } => gen_invokeproc(jit, asm, opnd!(recv), opnds!(args), *kw_splat, &function.frame_state(*state)),
         // Ensure we have enough room fit ec, self, and arguments
         // TODO remove this check when we have stack args (we can use Time.new to test it)
         Insn::InvokeBuiltin { bf, state, .. } if bf.argc + 2 > (C_ARG_OPNDS.len() as i32) => return Err(*state),
@@ -1497,6 +1498,35 @@ fn gen_invokeblock(
     )
 }
 
+fn gen_invokeproc(
+    jit: &mut JITState,
+    asm: &mut Assembler,
+    recv: Opnd,
+    args: Vec<Opnd>,
+    kw_splat: bool,
+    state: &FrameState,
+) -> lir::Opnd {
+    gen_prepare_non_leaf_call(jit, asm, state);
+
+    asm_comment!(asm, "call invokeproc");
+
+    let argv_ptr = gen_push_opnds(asm, &args);
+    let kw_splat_opnd = Opnd::Imm(i64::from(kw_splat));
+    let result = asm_ccall!(
+        asm,
+        rb_optimized_call,
+        recv,
+        EC,
+        args.len().into(),
+        argv_ptr,
+        kw_splat_opnd,
+        VM_BLOCK_HANDLER_NONE.into()
+    );
+    gen_pop_opnds(asm, &args);
+
+    result
+}
+
 /// Compile a dynamic dispatch for `super`
 fn gen_invokesuper(
     jit: &mut JITState,