[ruby-core:109456] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[ruby-core:109456] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been reported by shioyama (Chris Salzberg).

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:109457] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


Pull Request: https://github.com/ruby/ruby/pull/6226

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-98615

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:109623] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


I'm new to contributing to Ruby, but I haven't gotten a response on this in a couple weeks so wondering if maybe this requires more context.

For reference, here are the docs on the `wrap` parameter to [`Kernel#load`](https://ruby-doc.org/core-3.1.2/Kernel.html#method-i-load):

> If the optional _wrap_ parameter is true, the loaded script will be executed under an anonymous module, protecting the calling program's global namespace. If the optional _wrap_ parameter is a module, the loaded script will be executed under the given module. In no circumstance will any local variables in the loaded file be propagated to the loading environment.

So in theory if I have a file like this:

```ruby
# using.rb
using Module.new
```

then loading it with `wrap` in the following:

```ruby
MyModule = Module.new

load "./using.rb", MyModule
```

should be the same as this:

```ruby
module MyModule
  using Module.new
end
```

However, whereas the latter works fine, the former fails with the error reported in the issue.

Note that if I do the same inside of a block to `Module.new`, like this:

```ruby
Module.new do
  using Module.new
end
```

then I get a different error, `RuntimeError: Module#using is not permitted in methods`. So "the loaded script will be executed under an anonymous module" in the docs is somewhat misleading since it's not as simple as injecting the code in `using.rb` into the block to `Module.new`.

Regardless though I don't think the error I'm seeing ("main.using is permitted only at toplevel") is correct, I think this should work.

@jeremyevans0 You [most recently contributed to the `wrap` option](https://bugs.ruby-lang.org/issues/6210), what do you think about this? Would you see it as a bug?

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-98808

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:109624] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[jeremyevans0 (Jeremy Evans)]

Issue #18960 has been updated by jeremyevans0 (Jeremy Evans).


shioyama (Chris Salzberg) wrote in #note-3:
> @jeremyevans0 You [most recently contributed to the `wrap` option](https://bugs.ruby-lang.org/issues/6210), what do you think about this? Am I correct to consider this a bug, and [this](https://github.com/ruby/ruby/pull/6226) the correct fix?

I'm not sure whether this is a bug, but since `using` is permitted at top-;evel and also permitted in a module definition, it seems logical it should work at top-level with an implicit top-level module.  The pull request looks correct to me.  Not sure if the spec should use `ruby_bug`, I would just use `ruby_version_is`.

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-98809

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:109625] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shugo (Shugo Maeda)]

Issue #18960 has been updated by shugo (Shugo Maeda).


shioyama (Chris Salzberg) wrote in #note-3:
> @jeremyevans0 You [most recently contributed to the `wrap` option](https://bugs.ruby-lang.org/issues/6210), what do you think about this? Am I correct to consider this a bug, and [this](https://github.com/ruby/ruby/pull/6226) the correct fix?

main.using should not be called in a method definition even if it's a wrapped script.
With your fix, the following script causes BUG:

```
excelsior:ruby$ cat using_in_method.rb
# using.rb
def foo
  using Module.new
end

foo
excelsior:ruby$ cat t.rb
load "./using_in_method.rb", true
excelsior:ruby$ ./miniruby t.rb
/Users/shugo/src/ruby/using_in_method.rb:3: [BUG] vm_cref_dup: unreachable
ruby 3.2.0dev (2022-08-22T06:05:24Z shioyama-using_in_.. 08bdfcde78) [x86_64-darwin21]
```

I'm not sure whether this issue should be considered a bug, but it may be safe not to backport the fix to stable versions.




----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-98810

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:109626] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


@jeremyevans0

> I'm not sure whether this issue should be considered a bug, but it may be safe not to backport the fix to stable versions.

Yes, that's what I had originally, in review I changed it to `ruby_bug`. Happy to put it back.

@shugo Ah ok now I see the purpose of that error, thanks.

> I'm not sure whether this issue should be considered a bug, but it may be safe not to backport the fix to stable versions.

Sure that makes sense.

It seems like we have two things (1- not allowing main.using to be called in a method definition, and 2- evaluating code in a wrapped script as if it were namespaced in a module) that are mutually incompatible in this case.

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-98811

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110010] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[mame (Yusuke Endoh)]

Issue #18960 has been updated by mame (Yusuke Endoh).


We discussed this issue at the dev meeting. No one objected to correcting this behavior, but the proposed PR is unacceptable because it causes [BUG] as @shugo said. Could you investigate the issue and update the PR?

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99261

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110017] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


Thanks! I'll do that and update here once the PR is again ready for review.

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99268

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110019] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shugo (Shugo Maeda)]

Issue #18960 has been updated by shugo (Shugo Maeda).


I guess SEGV is caused by `using` in a method body, which should be prohibited even in a wrapped script.

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99270

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110021] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


Hmm, ok this is where the problem happens without the patch:

https://github.com/shioyama/rails/blob/b9493a47e65287f3b135904dbdd511bbf5a5798c/activesupport/lib/active_support/core_ext/enumerable.rb#L285-L291

```ruby
# Using Refinements here in order not to expose our internal method
using Module.new {
  refine Array do
    alias :orig_sum :sum
  end
}
```

Although this is somewhat contrived, you can reproduce the problem on the same file as follows:

```ruby
mod = Module.new
mod::Enumerable = Enumerable

load $LOAD_PATH.resolve_feature_path("active_support/core_ext/enumerable")[1], mod
# main.using is permitted only at toplevel (RuntimeError)
```

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99272

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110022] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


@shugo

Actually, it seems the same problem _is_ there with `require`:


```ruby
# foo.rb
def foo
  using Module.new
end

foo
```

```ruby
require "foo"
# main.using is permitted only at toplevel (RuntimeError)
```

So I don't really understand why Ruby allows the usage of `using` at toplevel with `require`, but not with `load`. Isn't this a problem in both cases?

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99273

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110023] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


Oh never mind, I see. My PR results in the error with `require` but the `unreachable` BUG with `load`.

Ok I'll try to find another way to fix it.

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99274

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110026] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shugo (Shugo Maeda)]

Issue #18960 has been updated by shugo (Shugo Maeda).


shioyama (Chris Salzberg) wrote in #note-12:
> Oh never mind, I see. My PR results in the error with `require` but the `unreachable` BUG with `load`.
> 
> Ok I'll try to find another way to fix it.

Yes, RuntimeError should be raised in both cases.


----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99277

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110031] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shioyama (Chris Salzberg)]

Issue #18960 has been updated by shioyama (Chris Salzberg).


@shugo I've updated my PR and added a spec calling a method which calls `using`, which fails with the previous code but passes with the updated code. Can you have a look?

----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99282

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/

[ruby-core:110043] [Ruby master Bug#18960] Module#using raises RuntimeError when called at toplevel from wrapped script

[shugo (Shugo Maeda)]

Issue #18960 has been updated by shugo (Shugo Maeda).


shioyama (Chris Salzberg) wrote in #note-14:
> @shugo I've updated [my PR](https://github.com/ruby/ruby/pull/6226) and added a spec calling a method which calls `using`, which fails with the previous code but passes with the updated code. Can you have a look?

Thank you!

I found another corner case.  The following code should be prohibited in a wrapped script:

```
MAIN = self

module X
  MAIN.send(:using, Module.new)
end
```

I suggested changes in the following comment:

https://github.com/ruby/ruby/pull/6226#pullrequestreview-1118228759


----------------------------------------
Bug #18960: Module#using raises RuntimeError when called at toplevel from wrapped script
https://bugs.ruby-lang.org/issues/18960#change-99293

* Author: shioyama (Chris Salzberg)
* Status: Open
* Priority: Normal
* ruby -v: 3.1.2p20
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I noticed that this file works when loaded with `load`, but fails if you pass `true` (or a module) as the `wrap` argument.

```ruby
# using.rb
using Module.new
```

This works:

```ruby
load "./using.rb"
```

This doesn't:
```ruby
load "./using.rb", true
# raises RuntimeError (main.using is permitted only at toplevel)
```

I believe the latter should work.



-- 
https://bugs.ruby-lang.org/