Tests: link minimal_parse_test with compiler deps (needs MethodCompiler)

KentBeck · KentBeck · commit 9a9dd4b77414 · 2025-08-29T06:12:56.000-07:00
diff --git a/src/cpp/include/smalltalk_class.h b/src/cpp/include/smalltalk_class.h
@@ -234,6 +234,8 @@ Class *getClassClass();
 Class *getMetaclassClass();
 Class *getIntegerClass();
 Class *getBooleanClass();
+Class *getTrueClass();
+Class *getFalseClass();
 Class *getSymbolClass();
 Class *getStringClass();
 Class *getBlockClass();
@@ -250,4 +252,4 @@ void addPrimitiveMethod(Class *clazz, const std::string &selector,
                         int primitiveNumber);
 } // namespace ClassUtils
 
-} // namespace smalltalk
+} // namespace smalltalk
diff --git a/src/cpp/run_all_tests.sh b/src/cpp/run_all_tests.sh
@@ -123,7 +123,7 @@ run_expression "(2 + 3) * 4" "Nested Expression"
 # 2. Test block parsing
 echo -e "\n${YELLOW}=== BLOCK PARSING TESTS ===${NC}"
 
-build_test "tests/minimal_parse_test.cpp" "minimal_parse_test" "$PARSER_DEPS"
+build_test "tests/minimal_parse_test.cpp" "minimal_parse_test" "$COMPILER_DEPS"
 run_test "Block Parsing" "./build/minimal_parse_test | grep -q 'Test completed successfully'"
 
 build_test "tests/simple_block_test.cpp" "simple_block_test" "$COMPILER_DEPS"
diff --git a/src/cpp/src/interpreter.cpp b/src/cpp/src/interpreter.cpp
@@ -291,12 +291,13 @@ void Interpreter::sendMessageBytecode() {
     throw std::runtime_error("Selector is not a symbol");
   }
 
-  // Pop arguments from stack (in reverse order)
+  // Pop arguments from stack (LIFO), then restore source order
   std::vector<TaggedValue> args;
   args.reserve(argCount);
   for (uint32_t i = 0; i < argCount; i++) {
     args.push_back(pop());
   }
+  std::reverse(args.begin(), args.end());
 
   // Pop receiver from stack
   TaggedValue receiver = pop();
@@ -610,7 +611,8 @@ Class *Interpreter::getObjectClass(TaggedValue value) {
     return ClassUtils::getIntegerClass();
   }
   if (value.isBoolean()) {
-    return ClassUtils::getBooleanClass();
+    return value.getBoolean() ? ClassUtils::getTrueClass()
+                              : ClassUtils::getFalseClass();
   }
   if (value.isNil()) {
     return ClassRegistry::getInstance().getClass("UndefinedObject");
diff --git a/src/cpp/src/method_compiler.cpp b/src/cpp/src/method_compiler.cpp
@@ -71,8 +71,7 @@ std::string MethodCompiler::parseMethodSignature(std::string &methodBody) {
 
     std::string fullSelector;
     for (; iter != end; ++iter) {
-      if (!fullSelector.empty())
-        fullSelector += ":";
+      // Append keyword part with trailing colon, no extra separator
       fullSelector += iter->str(1) + ":";
       parameters.push_back(iter->str(2));
     }
@@ -154,4 +153,4 @@ std::string MethodCompiler::parseMethodSignature(std::string &methodBody) {
   return selector;
 }
 
-} // namespace smalltalk
+} // namespace smalltalk
diff --git a/src/cpp/src/primitives/object.cpp b/src/cpp/src/primitives/object.cpp
@@ -154,7 +154,8 @@ TaggedValue primitive_class(TaggedValue receiver,
   if (receiver.isSmallInteger()) {
     receiverClass = ClassUtils::getIntegerClass();
   } else if (receiver.isBoolean()) {
-    receiverClass = ClassUtils::getBooleanClass();
+    receiverClass = receiver.getBoolean() ? ClassUtils::getTrueClass()
+                                          : ClassUtils::getFalseClass();
   } else if (receiver.isNil()) {
     // UndefinedObject class for nil
     receiverClass = ClassRegistry::getInstance().getClass("UndefinedObject");
@@ -192,4 +193,4 @@ void registerObjectPrimitives() {
                              ObjectPrimitives::primitive_class);
 }
 
-} // namespace smalltalk
+} // namespace smalltalk
diff --git a/src/cpp/src/smalltalk_class.cpp b/src/cpp/src/smalltalk_class.cpp
@@ -1,4 +1,5 @@
 #include "smalltalk_class.h"
+#include "method_compiler.h"
 #include "primitives.h"
 #include <algorithm>
 #include <iostream>
@@ -264,6 +265,8 @@ struct CoreClasses {
   Metaclass *metaclassClass = nullptr;
   Class *integerClass = nullptr;
   Class *booleanClass = nullptr;
+  Class *trueClass = nullptr;
+  Class *falseClass = nullptr;
   Class *symbolClass = nullptr;
   Class *stringClass = nullptr;
   Class *blockClass = nullptr;
@@ -315,13 +318,26 @@ void initializeCoreClasses() {
   core.integerClass->setClass(core.classClass);
   registry.registerClass("Integer", core.integerClass);
 
-  // Create Boolean class
+  // Create Boolean hierarchy
   core.booleanClass = new Class("Boolean", core.objectClass, nullptr);
   core.booleanClass->setInstanceSize(0); // Booleans are immediate values
   core.booleanClass->setFormat(ObjectFormat::POINTER_OBJECTS);
   core.booleanClass->setClass(core.classClass);
   registry.registerClass("Boolean", core.booleanClass);
 
+  // Create True/False as subclasses of Boolean
+  core.trueClass = new Class("True", core.booleanClass, nullptr);
+  core.trueClass->setInstanceSize(0);
+  core.trueClass->setFormat(ObjectFormat::POINTER_OBJECTS);
+  core.trueClass->setClass(core.classClass);
+  registry.registerClass("True", core.trueClass);
+
+  core.falseClass = new Class("False", core.booleanClass, nullptr);
+  core.falseClass->setInstanceSize(0);
+  core.falseClass->setFormat(ObjectFormat::POINTER_OBJECTS);
+  core.falseClass->setClass(core.classClass);
+  registry.registerClass("False", core.falseClass);
+
   // Create Symbol class
   core.symbolClass = new Class("Symbol", core.objectClass, nullptr);
   core.symbolClass->setInstanceSize(0); // Symbol data is managed internally
@@ -415,6 +431,24 @@ void initializeCoreClasses() {
   addPrimitiveMethod(core.blockClass, "value:",
                      PrimitiveNumbers::BLOCK_VALUE_ARG); // Block value:
 
+  // Install minimal boolean control-flow methods in True and False
+  // True
+  MethodCompiler::addSmalltalkMethod(core.trueClass,
+                                     "ifTrue: block\n^ block value");
+  MethodCompiler::addSmalltalkMethod(core.trueClass, "ifFalse: block\n^ nil");
+  MethodCompiler::addSmalltalkMethod(core.trueClass,
+                                     "ifTrue: t ifFalse: f\n^ t value");
+  MethodCompiler::addSmalltalkMethod(core.trueClass,
+                                     "ifFalse: f ifTrue: t\n^ t value");
+  // False
+  MethodCompiler::addSmalltalkMethod(core.falseClass, "ifTrue: block\n^ nil");
+  MethodCompiler::addSmalltalkMethod(core.falseClass,
+                                     "ifFalse: block\n^ block value");
+  MethodCompiler::addSmalltalkMethod(core.falseClass,
+                                     "ifTrue: t ifFalse: f\n^ f value");
+  MethodCompiler::addSmalltalkMethod(core.falseClass,
+                                     "ifFalse: f ifTrue: t\n^ f value");
+
   // Create SystemLoader class and add minimal start: primitive
   Class *systemLoaderClass =
       new Class("SystemLoader", core.objectClass, nullptr);
@@ -440,6 +474,8 @@ Class *getClassClass() { return CoreClasses::getInstance().classClass; }
 Class *getMetaclassClass() { return CoreClasses::getInstance().metaclassClass; }
 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 *getSymbolClass() { return CoreClasses::getInstance().symbolClass; }
 Class *getStringClass() { return CoreClasses::getInstance().stringClass; }
 Class *getBlockClass() { return CoreClasses::getInstance().blockClass; }
diff --git a/src/cpp/src/tagged_value.cpp b/src/cpp/src/tagged_value.cpp
@@ -24,7 +24,8 @@ Class *TaggedValue::getClass() const {
   if (isInteger()) {
     return ClassUtils::getIntegerClass();
   } else if (isBoolean()) {
-    return ClassUtils::getBooleanClass();
+    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
@@ -65,7 +66,9 @@ TaggedValue TaggedValue::fromObject(Object *object) {
       return *valueSlot;
     }
     // Check if it's a boxed boolean
-    if (object->getClass() == ClassUtils::getBooleanClass()) {
+    if (object->getClass() == ClassUtils::getBooleanClass() ||
+        object->getClass() == ClassUtils::getTrueClass() ||
+        object->getClass() == ClassUtils::getFalseClass()) {
       TaggedValue *valueSlot = reinterpret_cast<TaggedValue *>(
           reinterpret_cast<char *>(object) + sizeof(Object));
       return *valueSlot;
@@ -97,4 +100,4 @@ Object *TaggedValue::toObject(MemoryManager &memoryManager) const {
   }
 }
 
-} // namespace smalltalk
+} // namespace smalltalk
diff --git a/src/cpp/tests/all_expressions_test.cpp b/src/cpp/tests/all_expressions_test.cpp
@@ -574,7 +574,8 @@ aBlock value.
 
       // Conditionals - SHOULD FAIL (not implemented)
       {"3 < 4) ifTrue: [10] ifFalse: [20]", "10", false, "conditionals"},
-      {"true ifTrue: [42]", "42", false, "conditionals"},
+      {"true ifTrue: [42]", "42", true, "conditionals"},
+      {"false ifTrue: [1] ifFalse: [7]", "7", true, "conditionals"},
 
       // Collections - SHOULD FAIL (not implemented)
       {"#(1 2 3) at: 2", "2", true, "collections"},
diff --git a/src/cpp/tests/expression_test_runner b/src/cpp/tests/expression_test_runner

Original file line number	Diff line number	Diff line change
`@@ -291,12 +291,13 @@ void Interpreter::sendMessageBytecode() {`
`291`	`291`	`throw std::runtime_error("Selector is not a symbol");`
`292`	`292`	`}`
`293`	`293`
`294`		`- // Pop arguments from stack (in reverse order)`
	`294`	`+ // Pop arguments from stack (LIFO), then restore source order`
`295`	`295`	`std::vector<TaggedValue> args;`
`296`	`296`	`args.reserve(argCount);`
`297`	`297`	`for (uint32_t i = 0; i < argCount; i++) {`
`298`	`298`	`args.push_back(pop());`
`299`	`299`	`}`
	`300`	`+ std::reverse(args.begin(), args.end());`
`300`	`301`
`301`	`302`	`// Pop receiver from stack`
`302`	`303`	`TaggedValue receiver = pop();`
`@@ -610,7 +611,8 @@ Class *Interpreter::getObjectClass(TaggedValue value) {`
`610`	`611`	`return ClassUtils::getIntegerClass();`
`611`	`612`	`}`
`612`	`613`	`if (value.isBoolean()) {`
`613`		`- return ClassUtils::getBooleanClass();`
	`614`	`+ return value.getBoolean() ? ClassUtils::getTrueClass()`
	`615`	`+ : ClassUtils::getFalseClass();`
`614`	`616`	`}`
`615`	`617`	`if (value.isNil()) {`
`616`	`618`	`return ClassRegistry::getInstance().getClass("UndefinedObject");`
Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,7 @@ std::string MethodCompiler::parseMethodSignature(std::string &methodBody) {`
`71`	`71`
`72`	`72`	`std::string fullSelector;`
`73`	`73`	`for (; iter != end; ++iter) {`
`74`		`- if (!fullSelector.empty())`
`75`		`- fullSelector += ":";`
	`74`	`+ // Append keyword part with trailing colon, no extra separator`
`76`	`75`	`fullSelector += iter->str(1) + ":";`
`77`	`76`	`parameters.push_back(iter->str(2));`
`78`	`77`	`}`
`@@ -154,4 +153,4 @@ std::string MethodCompiler::parseMethodSignature(std::string &methodBody) {`
`154`	`153`	`return selector;`
`155`	`154`	`}`
`156`	`155`
`157`		`-} // namespace smalltalk`
	`156`	`+} // namespace smalltalk`