Add FunctionObjects test

Author: SomeRanDev

test/unit_testing/tests/FunctionObjects/.gitignore

@@ -0,0 +1,2 @@
+build
+out

test/unit_testing/tests/FunctionObjects/Main.hx

@@ -0,0 +1,35 @@
+package;
+
+import haxe.PosInfos;
+
+class Main {
+	static var returnCode = 0;
+	static function assert(b: Bool, infos: Null<PosInfos> = null) {
+		if(!b) {
+			haxe.Log.trace("Assert failed", infos);
+			returnCode = 1;
+		}
+	}
+
+	static var thing = 0;
+	static function bla() {
+		thing++;
+	}
+
+	public static function main() {
+		final func: () -> Void = bla;
+		func();
+		assert(thing == 1);
+
+		var func2: Null<() -> Void> = null;
+		if(func2 == null) {
+			func2 = bla;
+		}
+		func2();
+		assert(thing == 2);
+
+		if(returnCode != 0) {
+			Sys.exit(returnCode);
+		}
+	}
+}

test/unit_testing/tests/FunctionObjects/Test.hxml

@@ -0,0 +1,6 @@
+# The following are added automatically:
+# -lib reflaxe.cpp
+# -D cpp-output=out
+
+-D mainClass=Main
+-main Main

test/unit_testing/tests/FunctionObjects/intended/_GeneratedFiles.txt

@@ -0,0 +1,7 @@
+src/_main_.cpp
+src/Main.cpp
+include/haxe_PosInfos.h
+include/cxx_DynamicToString.h
+include/_AnonUtils.h
+include/_AnonStructs.h
+include/Main.h

test/unit_testing/tests/FunctionObjects/intended/include/Main.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include "haxe_PosInfos.h"
+
+class Main {
+public:
+	static int thing;
+	static int returnCode;
+
+	static void assert(bool b, std::optional<std::shared_ptr<haxe::PosInfos>> infos = std::nullopt);
+	static void bla();
+	static void main();
+};
+

test/unit_testing/tests/FunctionObjects/intended/include/_AnonStructs.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "_AnonUtils.h"
+
+#include <optional>
+
+namespace haxe {
+
+
+}

test/unit_testing/tests/FunctionObjects/intended/include/_AnonUtils.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include <optional>
+#include <memory>
+
+// haxe::shared_anon | haxe::unique_anon
+// Helper functions for generating "anonymous struct" smart pointers.
+namespace haxe {
+
+	template<typename Anon, class... Args>
+	std::shared_ptr<Anon> shared_anon(Args... args) {
+		return std::make_shared<Anon>(Anon::make(args...));
+	}
+
+	template<typename Anon, class... Args>
+	std::unique_ptr<Anon> unique_anon(Args... args) {
+		return std::make_unique<Anon>(Anon::make(args...));
+	}
+
+}
+
+// ---------------------------------------------------------------------
+
+// haxe::optional_info
+// Returns information about std::optional<T> types.
+namespace haxe {
+
+	template <typename T>
+	struct optional_info {
+		using inner = T;
+		static constexpr bool isopt = false;
+	};
+
+	template <typename T>
+	struct optional_info<std::optional<T>> {
+		using inner = typename optional_info<T>::inner;
+		static constexpr bool isopt = true;
+	};
+
+}
+
+// ---------------------------------------------------------------------
+
+
+// haxe::_unwrap_mm
+// Unwraps all the "memory management" types to get the underlying
+// value type. Also provided whether or not that type is deref-able.
+namespace haxe {
+
+	template<typename T>
+	struct _unwrap_mm {
+		using inner = T;
+		constexpr static bool can_deref = false;
+		static inline inner& get(T& in) { return in; }
+	};
+
+	template<typename T>
+	struct _unwrap_mm<T*> {
+		using inner = typename _unwrap_mm<T>::inner;
+		constexpr static bool can_deref = true;
+		static inline inner& get(T* in) { return _unwrap_mm<T>::get(*in); }
+	};
+
+	template<typename T>
+	struct _unwrap_mm<T&> {
+		using inner = typename _unwrap_mm<T>::inner;
+		constexpr static bool can_deref = false;
+		static inline inner& get(T& in) { return _unwrap_mm<T>::get(in); }
+	};
+
+	template<typename T>
+	struct _unwrap_mm<std::shared_ptr<T>> {
+		using inner = typename _unwrap_mm<T>::inner;
+		constexpr static bool can_deref = true;
+		static inline inner& get(std::shared_ptr<T> in) { return _unwrap_mm<T>::get(*in); }
+	};
+
+	template<typename T>
+	struct _unwrap_mm<std::unique_ptr<T>> {
+		using inner = typename _unwrap_mm<T>::inner;
+		constexpr static bool can_deref = true;
+		static inline inner& get(std::unique_ptr<T> in) { return _unwrap_mm<T>::get(*in); }
+	};
+
+	template<typename T, typename U = typename _unwrap_mm<T>::inner>
+	static inline U& unwrap(T in) { return _unwrap_mm<T>::get(in); }
+
+}
+
+// ---------------------------------------------------------------------
+
+// GEN_EXTRACTOR_FUNC
+// Generates a function named extract_[fieldName].
+//
+// Given any object, it checks whether that object has a field of the same name
+// and type as the class this function is a member of (using `haxe::optional_info`).
+//
+// If it does, it returns the object's field's value; otherwise, it returns `std::nullopt`.
+//
+// Useful for extracting values for optional parameters for anonymous structure
+// classes since the input object may or may not have the field.
+
+#define GEN_EXTRACTOR_FUNC(fieldName)\
+template<typename T, typename Other = decltype(T().fieldName), typename U = typename haxe::optional_info<Other>::inner>\
+static auto extract_##fieldName(T other) {\
+	if constexpr(!haxe::optional_info<decltype(fieldName)>::isopt && haxe::optional_info<Other>::isopt) {\
+		return other.customParam.get();\
+	} else if constexpr(std::is_same<U,haxe::optional_info<decltype(fieldName)>::inner>::value) {\
+		return other.customParam;\
+	} else {\
+		return std::nullopt;\
+	}\
+}
+
+

test/unit_testing/tests/FunctionObjects/intended/include/cxx_DynamicToString.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <deque>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include "_AnonUtils.h"
+
+namespace haxe {
+
+template<typename T, typename = std::string>
+struct has_to_string : std::false_type { };
+
+template<typename T>
+struct has_to_string <T, decltype(std::declval<T>().toString())> : std::true_type { };
+
+template<typename>
+struct is_deque : std::false_type {};
+
+template<typename T>
+struct is_deque<std::deque<T>> : std::true_type {};
+
+struct DynamicToString: public std::string {
+    template<typename T>
+    DynamicToString(T s): std::string(ToString(s)) {}
+
+    template<typename T>
+    static std::string ToString(T s) {
+		if constexpr(std::is_pointer<T>::value) {
+			if(s == nullptr) {
+				return "nullptr";
+			}
+		}
+        if constexpr(haxe::optional_info<T>::isopt) {
+			if(s.has_value()) {
+				return ToString(s.value());
+			} else {
+				return "null";
+			}
+		} else if constexpr(std::is_same_v<T, bool>) {
+			return s ? "true" : "false";
+		} else if constexpr(std::is_integral_v<T> || std::is_floating_point_v<T>) {
+			return std::to_string(s);
+		} else if constexpr(std::is_convertible<T, std::string>::value) {
+			return std::string(s);
+		} else if constexpr(has_to_string<T>::value) {
+			return s.toString();
+		} else if constexpr(haxe::_unwrap_mm<T>::can_deref) {
+			if constexpr(std::is_trivially_copy_assignable_v<std::remove_reference_t<decltype(*std::declval<T>())>>) {
+				return ToString(*s);
+			}
+		} else if constexpr(is_deque<T>::value) {
+			std::string result = "[";
+			auto len = s.size();
+			for(decltype(len) i = 0; i < len; i++) {
+				result += (i > 0 ? ", " : "") + ToString(s[i]);
+			}
+			return result + "]";
+		}
+
+		// Print address if all else fails
+		std::stringstream pointer_stream;
+		pointer_stream << std::addressof(s);
+		return "<unknown(address:" + pointer_stream.str() + ")>";
+    }
+};
+
+}

test/unit_testing/tests/FunctionObjects/intended/include/haxe_PosInfos.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <deque>
+#include <memory>
+#include <optional>
+#include <string>
+#include "_AnonStructs.h"
+#include "_AnonUtils.h"
+#include "cxx_DynamicToString.h"
+
+namespace haxe {
+
+// { className: String, fileName: String, lineNumber: Int, methodName: String, customParams: Null<Array<cxx.DynamicToString>> }
+struct PosInfos {
+
+	// default constructor
+	PosInfos() {}
+
+	// auto-construct from any object's fields
+	template<typename T>
+	PosInfos(T o):
+		className(haxe::unwrap(o).className),
+		fileName(haxe::unwrap(o).fileName),
+		lineNumber(haxe::unwrap(o).lineNumber),
+		methodName(haxe::unwrap(o).methodName),
+		customParams(extract_customParams(haxe::unwrap(o)))
+	{}
+
+	// construct fields directly
+	static PosInfos make(std::string className, std::string fileName, int lineNumber, std::string methodName, std::optional<std::shared_ptr<std::deque<haxe::DynamicToString>>> customParams = std::nullopt) {
+		PosInfos result;
+		result.className = className;
+		result.fileName = fileName;
+		result.lineNumber = lineNumber;
+		result.methodName = methodName;
+		result.customParams = customParams;
+		return result;
+	}
+
+	// fields
+	std::string className;
+	std::string fileName;
+	int lineNumber;
+	std::string methodName;
+	std::optional<std::shared_ptr<std::deque<haxe::DynamicToString>>> customParams;
+
+	GEN_EXTRACTOR_FUNC(customParams)
+};
+
+}

test/unit_testing/tests/FunctionObjects/intended/src/Main.cpp

@@ -0,0 +1,47 @@
+#include "Main.h"
+
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <string>
+#include "_AnonStructs.h"
+
+using namespace std::string_literals;
+
+int Main::thing = 0;
+
+int Main::returnCode = 0;
+
+void Main::assert(bool b, std::optional<std::shared_ptr<haxe::PosInfos>> infos) {
+	if(!b) {
+		{
+			auto temp = infos.value_or(haxe::shared_anon<haxe::PosInfos>("", "test/unit_testing/tests/FunctionObjects/Main.hx"s, 9, ""));
+			std::cout << temp->fileName << ":" << temp->lineNumber << ": " << "Assert failed"s << std::endl;
+		};
+		Main::returnCode = 1;
+	};
+}
+
+void Main::bla() {
+	Main::thing++;
+}
+
+void Main::main() {
+	std::function<void()> func = Main::bla;
+
+	func();
+	Main::assert(Main::thing == 1, haxe::shared_anon<haxe::PosInfos>("Main"s, "test/unit_testing/tests/FunctionObjects/Main.hx"s, 22, "main"s));
+
+	std::optional<std::function<void()>> func2 = std::nullopt;
+
+	if(!func2.has_value()) {
+		func2 = Main::bla;
+	};
+
+	func2.value_or(nullptr)();
+	Main::assert(Main::thing == 2, haxe::shared_anon<haxe::PosInfos>("Main"s, "test/unit_testing/tests/FunctionObjects/Main.hx"s, 29, "main"s));
+
+	if(Main::returnCode != 0) {
+		exit(Main::returnCode);
+	};
+}