From: "shyouhei (Shyouhei Urabe)" Date: 2022-07-22T00:24:56+00:00 Subject: [ruby-core:109294] [Ruby master Bug#18780] Incorrect binding receiver for C API rb_eval_string() Issue #18780 has been updated by shyouhei (Shyouhei Urabe). Updating the header document. ```patch From b968f277386649b7531a8999be54eacf3c599cdb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8D=9C=E9=83=A8=E6=98=8C=E5=B9=B3?= Date: Thu, 21 Jul 2022 18:00:04 +0900 Subject: [PATCH] [DOC] update rb_eval_string() document. --- include/ruby/internal/eval.h | 33 ++++++++++++++++++++++++++++++--- template/Doxyfile.tmpl | 1 + 2 files changed, 31 insertions(+), 3 deletions(-) diff --git a/include/ruby/internal/eval.h b/include/ruby/internal/eval.h index 34a53849da..b7ab66515f 100644 --- a/include/ruby/internal/eval.h +++ b/include/ruby/internal/eval.h @@ -28,10 +28,12 @@ RBIMPL_SYMBOL_EXPORT_BEGIN() RBIMPL_ATTR_NONNULL(()) /** - * Evaluates the given string in an isolated binding. + * Evaluates the given string. * - * Here "isolated" means that the binding does not inherit any other - * bindings. This behaves same as the binding for required libraries. + * In case it is called from within a C-backended method, the evaluation is + * done under the current binding. However there can be no method. On such + * situation this function evaluates in an isolated binding, like `require` + * runs in a separate one. * * `__FILE__` will be `"(eval)"`, and `__LINE__` starts from 1 in the * evaluation. @@ -39,6 +41,31 @@ RBIMPL_ATTR_NONNULL(()) * @param[in] str Ruby code to evaluate. * @exception rb_eException Raises an exception on error. * @return The evaluated result. + * + * @internal + * + * @shyouhei's old table about the birth and growth of this function: + * + * At the beginning, there was no rb_eval_string(). @shyouhei heard that + * @shugo, author of Apache httpd's mod_ruby module, requested @matz for this + * API. He wanted a way so that mod_ruby can evaluate ruby scripts one by one, + * separately, in each different contexts. So this function was made. It was + * designed to be a global interpreter entry point like ruby_run_node(). + * + * The way it is implemented however allows extension libraries (not just + * programs like Apache httpd) to call this function. Because its name says + * nothing about the initial design, people started to think of it as an + * orthodox way to call ruby level `eval` method from their extension + * libraries. Even our `extension.rdoc` has had a description of this function + * basically according to this understanding. + * + * The old (mod_ruby like) usage still works. But over time, usages of this + * function from extension libraries got popular, while mod_ruby faded out; is + * no longer maintained now. Devs decided to actively support both. This + * function now auto-detects how it is called, and switches how it works + * depending on it. + * + * @see https://bugs.ruby-lang.org/issues/18780 */ VALUE rb_eval_string(const char *str); diff --git a/template/Doxyfile.tmpl b/template/Doxyfile.tmpl index 36c0b1c8d6..502e171384 100644 --- a/template/Doxyfile.tmpl +++ b/template/Doxyfile.tmpl @@ -274,6 +274,7 @@ ALIASES += "old{1}=Old name of @ref \1.^^@deprecated Use @ref \1 i ALIASES += "shyouhei=\@shyouhei" ALIASES += "ko1=\@ko1" ALIASES += "matz=\@matz" +ALIASES += "shugo=\@shugo" # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For -- 2.17.1 ``` ---------------------------------------- Bug #18780: Incorrect binding receiver for C API rb_eval_string() https://bugs.ruby-lang.org/issues/18780#change-98431 * Author: daveola (David Stellar) * Status: Open * Priority: Normal * ruby -v: ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- % ruby -v ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux] (Though looking at the source code this problem still exists in ruby 3.0) The rb_eval_string() is seemingly capable of everything that eval is capable of, with one slight deviation. The binding is oddly setup to be correct except for the receiver/self. This means that while these both act the same: ruby: eval("puts someLocalVariable") C API: rb_eval_string("puts someLocalVariable") These do not: ruby: eval("puts @someInstanceVar") C API: rb_eval_string("puts @someInstanceVar") # nil And this is because these do not work: ruby: eval("puts self") # self of calling context ruby: eval("puts binding().receiver") # self of calling context C API: rb_eval_string("puts self") # main C API: rb_eval_string("puts binding().receiver") # main We can see the problem in the MRI source in ruby_eval_string_from_file() which has: return eval_string_with_cref(rb_vm_top_self(), rb_str_new2(str), NULL, file, 1); We've passed in rb_vm_top_self instead of the correct 'self' Although possibly the issue is in the API itself with the fact that there's no way to plumb through the receiver that you are given in the C extension method function call, i.e.: // My C extension that calls eval and knows what it's 'self' is. VALUE method_myCMethod(int argc, VALUE *argv, VALUE self) { rb_eval_string("..."); // <- no way to be given self? } Having said that, rb_eval_string is able to determine the vast majority of the binding context, since it correctly builds the binding() object *except* that the receiver is set to main, so perhaps this is something that *can* be determined. It is something that the builtin eval is able to do, after all. So possibly this is just a failure with MRI. I don't have other rubies to test. (I'm on ruby 2.7.0 but the source relevant to this hasn't changed.) I would argue this is a bug, because we are essentially given a corrupted result from binding() - one where we may have access to the local variables of an instance method, but one where the self itself is not properly set. That's not an actual legit binding state in the ruby code. -- https://bugs.ruby-lang.org/ Unsubscribe: