Core: add UndefinedObject class and normalize nil.class; tests: display Class names and add true/false/nil class cases (formatted)

Author: KentBeck

src/cpp/include/smalltalk_class.h

@@ -236,6 +236,7 @@ Class *getIntegerClass();
 Class *getBooleanClass();
 Class *getTrueClass();
 Class *getFalseClass();
+Class *getUndefinedObjectClass();
 Class *getSymbolClass();
 Class *getStringClass();
 Class *getBlockClass();

src/cpp/src/smalltalk_class.cpp

@@ -267,6 +267,7 @@ struct CoreClasses {
   Class *booleanClass = nullptr;
   Class *trueClass = nullptr;
   Class *falseClass = nullptr;
+  Class *undefinedObjectClass = nullptr;
   Class *symbolClass = nullptr;
   Class *stringClass = nullptr;
   Class *blockClass = nullptr;
@@ -338,6 +339,14 @@ void initializeCoreClasses() {
   core.falseClass->setClass(core.classClass);
   registry.registerClass("False", core.falseClass);
 
+  // Create UndefinedObject class (class of nil)
+  core.undefinedObjectClass =
+      new Class("UndefinedObject", core.objectClass, nullptr);
+  core.undefinedObjectClass->setInstanceSize(0);
+  core.undefinedObjectClass->setFormat(ObjectFormat::POINTER_OBJECTS);
+  core.undefinedObjectClass->setClass(core.classClass);
+  registry.registerClass("UndefinedObject", core.undefinedObjectClass);
+
   // Create Symbol class
   core.symbolClass = new Class("Symbol", core.objectClass, nullptr);
   core.symbolClass->setInstanceSize(0); // Symbol data is managed internally
@@ -476,6 +485,9 @@ Class *getIntegerClass() { return CoreClasses::getInstance().integerClass; }
 Class *getBooleanClass() { return CoreClasses::getInstance().booleanClass; }
 Class *getTrueClass() { return CoreClasses::getInstance().trueClass; }
 Class *getFalseClass() { return CoreClasses::getInstance().falseClass; }
+Class *getUndefinedObjectClass() {
+  return CoreClasses::getInstance().undefinedObjectClass;
+}
 Class *getSymbolClass() { return CoreClasses::getInstance().symbolClass; }
 Class *getStringClass() { return CoreClasses::getInstance().stringClass; }
 Class *getBlockClass() { return CoreClasses::getInstance().blockClass; }

src/cpp/src/tagged_value.cpp

@@ -27,9 +27,8 @@ Class *TaggedValue::getClass() const {
     return getBoolean() ? ClassUtils::getTrueClass()
                         : ClassUtils::getFalseClass();
   } else if (isNil()) {
-    // nil is a special case - it's the sole instance of UndefinedObject
-    // For now, we'll return Object class
-    return ClassUtils::getObjectClass();
+    // nil's class is UndefinedObject
+    return ClassUtils::getUndefinedObjectClass();
   } else if (isPointer()) {
     try {
       // Strings are byte-indexable and detected via utility

src/cpp/tests/all_expressions_test.cpp

@@ -91,6 +91,9 @@ void testExpressionWithExecuteMethod(const ExpressionTest &test) {
             Symbol *symbol = static_cast<Symbol *>(obj);
             resultStr = "Symbol(" + symbol->getName() + ")";
           }
+        } else if (obj && obj->header.getType() == ObjectType::CLASS) {
+          Class *cls = static_cast<Class *>(obj);
+          resultStr = cls->getName();
         } else {
           // Debug: show actual object type
           resultStr = "Object(type=" +
@@ -545,6 +548,9 @@ aBlock value.
       {"false", "false", true, "literals"},
       {"nil", "nil", true, "literals"},
       {"#abc", "Symbol(abc)", true, "literals"},
+      {"true class", "True", true, "literals"},
+      {"false class", "False", true, "literals"},
+      {"nil class", "UndefinedObject", true, "literals"},
 
       // Variable assignment - SHOULD PASS (now implemented!)
       {"| x | x := 42. x", "42", true, "variables"},
@@ -726,6 +732,9 @@ aBlock value.
               if (obj && obj->header.getType() == ObjectType::SYMBOL) {
                 Symbol *sym = static_cast<Symbol *>(obj);
                 resultStr = sym->toString();
+              } else if (obj && obj->header.getType() == ObjectType::CLASS) {
+                Class *cls = static_cast<Class *>(obj);
+                resultStr = cls->getName();
               } else if (obj && obj->header.getType() == ObjectType::ARRAY) {
                 // Format array as <Array size: N>
                 size_t arraySize = obj->header.size;