Rename class_name => name for Modules

include/natalie/class_object.hpp

@@ -62,8 +62,8 @@ class ClassObject : public ModuleObject {
     virtual String backtrace_name() const override final;
 
     virtual void gc_inspect(char *buf, size_t len) const override {
-        if (m_class_name)
-            snprintf(buf, len, "<ClassObject %p name=%s>", this, m_class_name.value().c_str());
+        if (m_name)
+            snprintf(buf, len, "<ClassObject %p name=%s>", this, m_name.value().c_str());
         else
             snprintf(buf, len, "<ClassObject %p name=(none)>", this);
     }

include/natalie/module_object.hpp

@@ -67,17 +67,17 @@ class ModuleObject : public Object {
 
     Value eval_body(Env *, Value (*)(Env *, Value));
 
-    Optional<String> class_name() const {
-        return m_class_name;
+    Optional<String> name() const {
+        return m_name;
     }
 
-    void set_class_name(String name) {
-        m_class_name = std::move(name);
+    void set_name(String name) {
+        m_name = std::move(name);
     }
 
-    void set_class_name(const char *name) {
+    void set_name(const char *name) {
         assert(name);
-        m_class_name = String(name);
+        m_name = String(name);
     }
 
     virtual ClassObject *superclass(Env *) { return m_superclass; }
@@ -126,7 +126,7 @@ class ModuleObject : public Object {
     Value inspect(Env *) const;
     String dbg_inspect() const override;
     Value name(Env *) const;
-    Optional<String> name() { return m_class_name; }
+    Optional<String> name() { return m_name; }
     virtual String backtrace_name() const;
 
     ArrayObject *attr(Env *, Args &&);
@@ -171,8 +171,8 @@ class ModuleObject : public Object {
     virtual void visit_children(Visitor &) const override final;
 
     virtual void gc_inspect(char *buf, size_t len) const override {
-        if (m_class_name)
-            snprintf(buf, len, "<ModuleObject %p name=%s>", this, m_class_name.value().c_str());
+        if (m_name)
+            snprintf(buf, len, "<ModuleObject %p name=%s>", this, m_name.value().c_str());
         else
             snprintf(buf, len, "<ModuleObject %p name=(none)>", this);
     }
@@ -185,7 +185,7 @@ class ModuleObject : public Object {
 
     Env *m_env { nullptr };
     TM::Hashmap<SymbolObject *, Constant *> m_constants {};
-    Optional<String> m_class_name {};
+    Optional<String> m_name {};
     ClassObject *m_superclass { nullptr };
     TM::Hashmap<SymbolObject *, MethodInfo> m_methods {};
     TM::Hashmap<SymbolObject *, Value> m_class_vars {};

lib/yaml.cpp

@@ -176,7 +176,7 @@ static void emit_openstruct_value(Env *env, Value value, yaml_emitter_t &emitter
 
 static void emit_struct_value(Env *env, Value value, yaml_emitter_t &emitter, yaml_event_t &event) {
     TM::String mapping_header = "!ruby/struct";
-    if (auto name = value->klass()->class_name()) {
+    if (auto name = value->klass()->name()) {
         mapping_header.append_char(':');
         mapping_header.append(*name);
     }

src/class_object.cpp

@@ -42,7 +42,7 @@ void ClassObject::initialize_subclass_without_checks(ClassObject *subclass, Env
         subclass->set_singleton_class(singleton);
     }
     if (!name.is_empty())
-        subclass->set_class_name(name);
+        subclass->set_name(name);
     subclass->m_superclass = this;
     if (!object_type)
         object_type = m_object_type;
@@ -57,7 +57,7 @@ ClassObject *ClassObject::bootstrap_class_class(Env *env) {
     Class->m_klass = Class;
     Class->m_object_type = Type::Class;
     Class->m_is_initialized = true;
-    Class->set_class_name("Class");
+    Class->set_name("Class");
     return Class;
 }
 
@@ -68,17 +68,17 @@ ClassObject *ClassObject::bootstrap_basic_object(Env *env, ClassObject *Class) {
     BasicObject->m_klass = Class;
     BasicObject->m_superclass = nullptr;
     BasicObject->m_is_initialized = true;
-    BasicObject->set_class_name("BasicObject");
+    BasicObject->set_name("BasicObject");
     auto singleton = new ClassObject { Class };
     Class->initialize_subclass_without_checks(singleton, env, "#<Class:BasicObject>");
     BasicObject->set_singleton_class(singleton);
     return BasicObject;
 }
 
 String ClassObject::backtrace_name() const {
-    if (!m_class_name)
+    if (!m_name)
         return inspect_str();
-    return String::format("<class:{}>", m_class_name.value());
+    return String::format("<class:{}>", m_name.value());
 }
 
 }

src/exception_object.cpp

@@ -139,7 +139,7 @@ Value ExceptionObject::detailed_message(Env *env, Args &&args) {
         return message;
     }
 
-    if (!klass()->class_name())
+    if (!klass()->name())
         return message;
 
     const char *fmt = highlight ? "\e[1m{} (\e[1;4m{}\e[m\e[1m)\e[m" : "{} ({})";

src/kernel_module.cpp

@@ -420,8 +420,8 @@ Value KernelModule::inspect(Env *env) {
 }
 
 Value KernelModule::inspect(Env *env, Value value) {
-    if (value->is_module() && value->as_module()->class_name()) {
-        return new StringObject { value->as_module()->class_name().value() };
+    if (value->is_module() && value->as_module()->name()) {
+        return new StringObject { value->as_module()->name().value() };
     } else {
         return StringObject::format("#<{}:{}>", value->klass()->inspect_str(), value->pointer_id());
     }

src/module_object.cpp

@@ -7,7 +7,7 @@ ModuleObject::ModuleObject()
 
 ModuleObject::ModuleObject(const char *name)
     : ModuleObject {} {
-    this->set_class_name(name);
+    this->set_name(name);
 }
 
 ModuleObject::ModuleObject(Type type, ClassObject *klass)
@@ -272,14 +272,14 @@ Value ModuleObject::const_set(SymbolObject *name, Value val) {
             if (val->singleton_class()) val->singleton_class()->set_owner(this);
         }
 
-        if (!val->as_module()->class_name()) {
-            auto class_name = name->string();
-            val->as_module()->set_class_name(class_name);
+        if (!val->as_module()->name()) {
+            auto module_name = name->string();
+            val->as_module()->set_name(module_name);
 
             auto singleton_class = val->singleton_class();
             while (singleton_class) {
-                class_name = String::format("#<Class:{}>", class_name);
-                singleton_class->set_class_name(class_name);
+                auto class_name = String::format("#<Class:{}>", module_name);
+                singleton_class->set_name(class_name);
                 singleton_class = singleton_class->singleton_class();
             }
         }
@@ -734,16 +734,16 @@ bool ModuleObject::is_method_defined(Env *env, Value name_value) const {
 }
 
 String ModuleObject::inspect_str() const {
-    if (m_class_name) {
+    if (m_name) {
         if (owner() && owner() != GlobalEnv::the()->Object()) {
-            return String::format("{}::{}", owner()->inspect_str(), m_class_name.value());
+            return String::format("{}::{}", owner()->inspect_str(), m_name.value());
         } else {
-            return String(m_class_name.value());
+            return String(m_name.value());
         }
     } else if (is_class()) {
         return String::format("#<Class:{}>", pointer_id());
-    } else if (is_module() && m_class_name) {
-        return String(m_class_name.value());
+    } else if (is_module() && m_name) {
+        return String(m_name.value());
     } else {
         return String::format("#<{}:{}>", klass()->inspect_str(), pointer_id());
     }
@@ -754,14 +754,14 @@ Value ModuleObject::inspect(Env *env) const {
 }
 
 String ModuleObject::dbg_inspect() const {
-    if (m_class_name)
-        return String::format("\"{}\"", m_class_name.value());
+    if (m_name)
+        return String::format("\"{}\"", m_name.value());
     return Object::dbg_inspect();
 }
 
 Value ModuleObject::name(Env *env) const {
-    if (m_class_name) {
-        String name = m_class_name.value();
+    if (m_name) {
+        String name = m_name.value();
         auto the_owner = owner();
         if (the_owner && the_owner != GlobalEnv::the()->Object()) {
             auto owner_name = the_owner->name();
@@ -777,9 +777,9 @@ Value ModuleObject::name(Env *env) const {
 }
 
 String ModuleObject::backtrace_name() const {
-    if (!m_class_name)
+    if (!m_name)
         return inspect_str();
-    return String::format("<module:{}>", m_class_name.value());
+    return String::format("<module:{}>", m_name.value());
 }
 
 ArrayObject *ModuleObject::attr(Env *env, Args &&args) {

src/object.cpp

@@ -1315,7 +1315,7 @@ bool Object::neq(Env *env, Value other) {
 }
 
 String Object::dbg_inspect() const {
-    auto klass = m_klass->class_name();
+    auto klass = m_klass->name();
     return String::format(
         "#<{}:{}>",
         klass ? *klass : "Object",
@@ -1469,7 +1469,7 @@ HashObject *Object::to_hash(Env *env) {
 StringObject *Object::to_s(Env *env) {
     auto str = send(env, "to_s"_s);
     if (!str->is_string())
-        env->raise("TypeError", "no implicit conversion of {} into String", m_klass->class_name());
+        env->raise("TypeError", "no implicit conversion of {} into String", m_klass->name());
     return str->as_string();
 }
 

src/value.cpp

@@ -17,7 +17,7 @@ Value Value::floatingpoint(double value) {
                 return String("FastInteger");                                           \
             if (val.m_type == Type::Double)                                             \
                 return String("FastDouble");                                            \
-            auto maybe_classname = val->klass()->class_name();                          \
+            auto maybe_classname = val->klass()->name();                                \
             if (maybe_classname.present())                                              \
                 return maybe_classname.value();                                         \
             else                                                                        \