Implements support for functions with the same name, but different parameters

src/UserData/UserDataFunction.cpp

@@ -6,7 +6,10 @@ using namespace Porygon::Evaluation;
 namespace Porygon::UserData{
     extern "C" {
         EvalValue * CreateFunctionEvalValue(Evaluation::EvalValue* (*func)(void* , EvalValue* [], int ), void* obj) {
-            return new UserDataFunction(func, obj);
+            auto opt = new UserDataFunction(func, obj);
+            auto t = new GenericFunctionEvalValue(make_shared<GenericFunctionScriptType>(), rand());
+            t->RegisterOption(opt);
+            return t;
         }
     }
 }

src/UserData/UserDataFunction.hpp

@@ -4,32 +4,28 @@
 #include <utility>
 #include "../Evaluator/EvalValues/ScriptFunctionEvalValue.hpp"
 #include "UserDataFunctionType.hpp"
+#include "../FunctionScriptType.hpp"
 
 namespace Porygon::UserData{
-    class UserDataFunction : public Evaluation::GenericFunctionEvalValue {
-        Evaluation::EvalValue* (*_call)(void* obj, EvalValue* parameters[], int parameterCount);
+    class UserDataFunction : public Evaluation::GenericFunctionOption {
+        Evaluation::EvalValue* (*_call)(void* obj, Evaluation::EvalValue* parameters[], int parameterCount);
         void *_obj;
 
-        UserDataFunction(Evaluation::EvalValue* (*call)(void* obj, EvalValue* parameters[], int parameterCount), void* obj,
-                         shared_ptr<GenericFunctionScriptType> type, size_t hash) : GenericFunctionEvalValue(std::move(type), hash){
+        UserDataFunction(Evaluation::EvalValue* (*call)(void* obj, Evaluation::EvalValue* parameters[], int parameterCount), void* obj,
+                         shared_ptr<GenericFunctionScriptType> type, size_t hash) : GenericFunctionOption(){
             _call = call;
             _obj = obj;
         }
     public:
-        UserDataFunction(Evaluation::EvalValue* (*call)(void* obj, EvalValue* parameters[], int parameterCount), void* obj) :
-        GenericFunctionEvalValue(make_shared<UserDataFunctionType>(nullptr, vector<shared_ptr<ScriptType>>{}), rand()){
+        UserDataFunction(Evaluation::EvalValue* (*call)(void* obj, Evaluation::EvalValue* parameters[], int parameterCount), void* obj) :
+                GenericFunctionOption(){
             _call = call;
             _obj = obj;
         }
 
-        EvalValue* Call(EvalValue* parameters[], int parameterCount){
+        Evaluation::EvalValue* Call(Evaluation::EvalValue* parameters[], int parameterCount){
             return _call(_obj, parameters, parameterCount);
         }
-
-        const shared_ptr<EvalValue> Clone() const final {
-            // We don't run make_shared here as it can't call private constructors
-            return shared_ptr<UserDataFunction>(new UserDataFunction(_call, _obj, _type, _hash));
-        }
     };
 }
 

src/UserData/UserDataFunctionType.hpp

@@ -3,26 +3,27 @@
 
 #include <utility>
 #include "../ScriptType.hpp"
+#include "../FunctionScriptType.hpp"
 
 namespace Porygon::UserData{
-    class UserDataFunctionType : public GenericFunctionScriptType{
+    class UserDataFunctionOption : public GenericFunctionOption{
     public:
-        UserDataFunctionType(std::shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes)
-        : GenericFunctionScriptType(std::move(returnType), std::move(parameterTypes)){
+        UserDataFunctionOption(std::shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes)
+        : GenericFunctionOption(std::move(returnType), std::move(parameterTypes)) {
 
         }
-        static UserDataFunctionType* FromRawPointers(ScriptType* returnType, vector<ScriptType*> parameterTypes){
+        static UserDataFunctionOption* FromRawPointers(ScriptType* returnType, vector<ScriptType*> parameterTypes){
             auto rt = shared_ptr<ScriptType>(returnType);
             auto p = vector<shared_ptr<ScriptType>>(parameterTypes.size());
             for (int i = 0; i < parameterTypes.size(); i++){
                 p[i] = shared_ptr<ScriptType>(parameterTypes[i]);
             }
-            return new UserDataFunctionType(rt, p);
+            return new UserDataFunctionOption(rt, p);
         }
 
-        static UserDataFunctionType* FromRawPointers(ScriptType* returnType){
+        static UserDataFunctionOption* FromRawPointers(ScriptType* returnType){
             auto rt = shared_ptr<ScriptType>(returnType);
-            return new UserDataFunctionType(rt, {});
+            return new UserDataFunctionOption(rt, {});
         }
 
 

src/UserData/UserDataTemplates.hpp

@@ -67,14 +67,18 @@
 #define PORYGON_FUNCTION(fieldName, returnType, ...) \
     { \
         Porygon::Utilities::HashedString::ConstHash(#fieldName), \
-        new Porygon::UserData::UserDataField(Porygon::UserData::UserDataFunctionType::FromRawPointers(returnType,  {__VA_ARGS__}  ), \
+        new Porygon::UserData::UserDataField( \
+                new Porygon::GenericFunctionScriptType( \
+                Porygon::UserData::UserDataFunctionOption::FromRawPointers(returnType,  {__VA_ARGS__}  )), \
         \
         \
         [](void* obj) -> Porygon::Evaluation::EvalValue* { \
-                return new Porygon::UserData::UserDataFunction( \
+                auto t = new Porygon::Evaluation::GenericFunctionEvalValue(make_shared<GenericFunctionScriptType>(), rand()); \
+                t->RegisterOption(new Porygon::UserData::UserDataFunction( \
                 [](void* obj, Porygon::Evaluation::EvalValue* par[], int parameterCount) \
                     -> Porygon::Evaluation::EvalValue*{return ((T_USERDATA*)obj)->invoke__##fieldName(obj, par, parameterCount);},  \
-                obj);}, \
+                obj)); \
+                return t;}, \
         nullptr) \
     },