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

Status changed from Open to Feedback
File mod-reopen-error-message.patch added

The reason for the difference in behavior here is due to Ruby's open classes.  When using `class X` or `module X`, if the constant `X` is already defined, Ruby will reopen the class or module definition, so you can operate in the context of the class or module.  However, attempting to reopen a class when the object is not actually a class is a error, whereas reassigning a constant is just a warning.

The warning message you get during constant reassignment is used for classes and modules if you assign them:

```ruby
X = Class.new
X = Module.new
# warning: already initialized constant X
# warning: previous definition of X was here
```

Likewise, the error raised when attempting to reopening an existing constant is pretty much the same for all objects that don't match the expected type:

```ruby
X = 1
class X; end
# TypeError (X is not a class)
module X; end
# TypeError (X is not a module)
```

So I don't think there is a bug here.  It is possible to change the format the error message, though.  Attached is a patch that changes the error message to the include the current class of the object:

```ruby
class X;end
module X;end
# TypeError (X is not a module, it is a Class)
module Y;end
class Y;end
# TypeError (Y is not a class, it is a Module)
```

I would appreciate feedback on whether this more detailed error message is an improvement.

----------------------------------------
Bug #11460: Unhelpful error message when naming a module with the same name as an existing class
https://bugs.ruby-lang.org/issues/11460#change-79086

* Author: iMIchael (Michael Martinez)
* Status: Feedback
* Priority: Normal
* Assignee: 
* Target version: 
* ruby -v: ruby 2.2.0p0
* Backport: 2.0.0: UNKNOWN, 2.1: UNKNOWN, 2.2: UNKNOWN
----------------------------------------
# Summary
The error message when naming a module with the same name as an existing class causes more trouble then it helps.

# Steps to Reproduce
~~~
class X;end
module X;end
=> TypeError: X is not a module
~~~

# Expected Results
Ruby has this very helpful and explicit error when reassigning a value to an existing constant. 

~~~
A = 1
A = 2
warning: already initialized constant A
warning: previous definition of A was here
~~~

which makes me expect Ruby to keep track of names of global constants and prevent me from colliding names with helpful warnings. This warning however raises a "Type error" which is not very intuitive. When users think of type errors they think of things like "foo" * "foo" => TypeError: no implicit conversion of String into Integer. 

# Actual Results
Confusion about what the actual error is, especially for people learning Ruby.

---Files--------------------------------
mod-reopen-error-message.patch (2.82 KB)


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

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>