POLYMORPHIC PIONTERS

Author: Youg-Otricked

3

@@ -1208,6 +1208,8 @@ class LLVMCompiler {
     std::unordered_map<std::string, llvm::StructType*> structTypes;
     std::unordered_map<std::string, llvm::StructType*> unionTypes;
     std::unordered_map<std::string, llvm::StructType*> classTypes;
+    std::unordered_map<std::string, llvm::GlobalVariable*> vtables;
+    std::unordered_map<std::string, std::unordered_map<std::string, int>> vtableSlotIndex;
     std::unordered_map<std::string, std::unordered_map<std::string, std::vector<llvm::Function*>>> classMethods;
     llvm::Value* currentThis = nullptr;
     std::string currentClassName = "";
@@ -1321,7 +1323,7 @@ class LLVMCompiler {
         } else if (auto unaryOp = std::get_if<UnaryOpNode*>(&node)) {
             std::string type = getExpressionType((*unaryOp)->node, strip);
             if ((*unaryOp)->op_tok.type == TokenType::MUL) {
-                if (type.ends_with("*")) { type.pop_back(); }
+                if (type.ends_with("*") && strip) { type.pop_back(); }
             }
             return type;
         } else if (auto binOp = std::get_if<BinOpNode*>(&node)) {
@@ -1541,6 +1543,7 @@ class LLVMCompiler {
             return addr;
         } else if (auto unary = std::get_if<UnaryOpNode*>(&node)) {
             if ((*unary)->op_tok.type == TokenType::MUL) { return emitExpr((*unary)->node); }
+            if ((*unary)->op_tok.type == TokenType::AMPERSAND) { return emitLValue((*unary)->node); }
         } else if (auto prop = std::get_if<PropertyAccessNode*>(&node)) {
             return emitPropertyAddress(**prop);
         } else if (auto call = std::get_if<CallNode*>(&node)) {
@@ -2130,6 +2133,24 @@ class LLVMCompiler {
         }
         return builder->CreateCall(method, reconciled, name + "_result");
     }
+    std::string resolveVirtualTargetClass(const std::string& declaredClass, 
+                                       const std::string& methodName, 
+                                       size_t argCount) {
+        for (auto& m : userTypes[declaredClass].classMethods) {
+            if (m.name_tok.value == methodName && m.params.size() == argCount)
+                return declaredClass;
+        }
+        for (auto& [name, info] : userTypes) {
+            if (info.baseClassName == declaredClass) {
+                for (auto& m : info.classMethods) {
+                    if (m.name_tok.value == methodName && m.params.size() == argCount)
+                        return name;
+                }
+            }
+        }
+        return declaredClass;
+    }
+
     llvm::Function* findMethodOverload(const std::string& className, const std::string& methodName, const std::vector<llvm::Value*>& args) {
         std::string resolvedClassName = className;
         if (className.find("::") == std::string::npos && !getCurrentNamespace().empty()) {
@@ -2220,6 +2241,38 @@ class LLVMCompiler {
 
         return nullptr;
     }
+    llvm::Value* emitVirtualOrDirectCall(
+        const std::string& ty,
+        const std::string& methodName,
+        llvm::Value* payload,
+        const std::vector<llvm::Value*>& args)
+    {
+        auto vtableIt = vtables.find(ty);
+        auto slotIt = vtableSlotIndex.find(ty);
+        if (vtableIt != vtables.end() && slotIt != vtableSlotIndex.end()) {
+            std::string mangledName = ty + "_" + methodName;
+            auto indexIt = slotIt->second.find(mangledName);
+            if (indexIt != slotIt->second.end()) {
+                int slotIndex = indexIt->second;
+                llvm::StructType* classTy = classTypes[ty];
+                llvm::Value* vptrField = builder->CreateStructGEP(classTy, payload, 0, "vptr_field");
+                llvm::Value* vptr = builder->CreateLoad(builder->getPtrTy(), vptrField, "vptr");
+                llvm::Value* fnPtrAddr = builder->CreateGEP(builder->getPtrTy(), vptr,
+                                            builder->getInt32(slotIndex), "vtable_slot");
+                llvm::Value* fnPtr = builder->CreateLoad(builder->getPtrTy(), fnPtrAddr, "fn_ptr");
+
+                llvm::Function* method = findMethodOverload(ty, methodName, args);
+                if (!method) return nullptr;
+
+                std::vector<llvm::Value*> allArgs = {payload};
+                allArgs.insert(allArgs.end(), args.begin(), args.end());
+                return builder->CreateCall(method->getFunctionType(), fnPtr, allArgs);
+            }
+        }
+        llvm::Function* method = findMethodOverload(ty, methodName, args);
+        if (!method) return nullptr;
+        return emitMethodCall(method, payload, args, methodName);
+    }
     llvm::Function* generateSpecializedMethod(const std::string& className, size_t methodIdx, const std::vector<std::string>& concreteTypes,
                                               const std::string& specializedName) {
         llvm::Function* savedFunction = currentFunction;

a.ll

@@ -20,7 +20,7 @@
 #if defined(_WIN32) || defined(_WIN64)
 #include <print>
 #endif
-const std::string ver = "x0.17.73";
+const std::string ver = "x0.17.75";
 #include <random>
 bool slow = false;
 void slow_print(const std::string& text, const std::string& color = "\033[0m", int min_delay_ms = 100, int max_delay_ms = 450) {

compiler.cpp

@@ -1,4 +1,3 @@
-- Array-initing pointers
 - Concepts
 ```
 concept X {
@@ -10,7 +9,6 @@ class Y {
 Y proves X;
 ```
 - Try/Catch 
-- Polymorphic pointers. Class* = &Child
 - Generics (`class List<T, int S>`....., `class MultiNumbers<T(!int|double|float)>`, `class VaradicTypes<...Tys>`)
 - Operator[i] (subscript, eg `class[123]`), operator[](brace initialization, eg `Classname c = [1, 2, 3, 4]`), operator{:}(map initialization, e.g. `Classname c = {"true": 1, "false": 0};`)
 - Code block functions (`void myKey() code { code.eval }; int main() { myKey () { …. } }`)
@@ -77,19 +75,17 @@ void loop(void) code {
 - qconform (QC Formatter)
 - operator++/–/+=/-=//=/*=(combinational operators)
 TOP PRIORITY:
-1. Array-initing pointers.
-2. Polymorphic pointers.
-3. Generics.
-4. Self host the runtime.
-5. Try/Catch.
-6. Fancy operator overloads
-7. Token/ident/type/keyword/usertype direct type (parser refactor)
-8. Codeblocks.
-9. Concepts
-10. Modifier (x1.0.0)
-11. CQB.
-12. Other stuff
-13. Metadata
+1. Generics.
+2. Self host the runtime.
+3. Try/Catch.
+4. Fancy operator overloads
+5. Token/ident/type/keyword/usertype direct type (parser refactor)
+6. Codeblocks.
+7. Concepts
+8. Modifier (x1.0.0)
+9. CQB.
+10. Other stuff
+11. Metadata
 ?likely? - likely marked
 ?unlikely? - marked unlikely
 ?inline? - pls inline >-<

compiler.h

@@ -0,0 +1,23 @@
+class A {
+    int add(int a) {
+        return a + 2;
+    }
+    A() {
+    }
+}
+class B : A {
+    int add(int a, int b) {
+        return a + b;
+    }
+    B() {
+    }
+}
+int main() {
+    A a = A();
+    A* aClass = &a;
+    qout("%i", aClass->add(123));
+    B b = B();
+    aClass = &b;
+    qout("%i", aClass->add(123, 321));
+    return 0;
+} // just need to handle the actusal method calls

compiler_run.cpp

@@ -1 +1 @@
-x0.17.73
+x0.17.75