Guus/param var conv

.github/workflows/build-linux.yml

@@ -202,7 +202,6 @@ jobs:
           lcov \
             --capture \
             --directory build/src \
-            --directory build/modules \
             --output-file coverage/coverage.info
           # remove external dependencies
           lcov \

.github/workflows/test-macos-gpu.yml

@@ -171,7 +171,6 @@ jobs:
           lcov \
             --capture \
             --directory build/src \
-            --directory build/modules \
             --output-file coverage/coverage.info \
             --ignore-errors inconsistent,gcov,range,format
           # remove external dependencies

cmake/Modules.cmake

@@ -7,24 +7,23 @@ option(SHARDS_WITH_DEFAULT "Default SHARDS_WITH_<name> state of modules" OFF)
 # The same happens for the rust modules
 #
 # If you have any dependencies between the two, you should link both targets against each other in a ciruclar fashion
-# on the final executable target, e.g.: 
-#   target_link_libraries(shards-rust_union shards-cpp-union)
-#   target_link_libraries(shards-cpp-union shards-rust-union)
+# on the final executable target, e.g.:
+# target_link_libraries(shards-rust_union shards-cpp-union)
+# target_link_libraries(shards-cpp-union shards-rust-union)
 #
 # If any of the cpp modules for example has a dependency that needs any rust code (for example, gfx, gfx-core)
 # you need to link in that dependency as an OBJECT library as well, so it will be in the same static union lib
 #
 # Since you can not chain OBJECT libraries in cmake (it will miss the lowest level objects)
 # you can set up an intermediate interface target like this:
-#   add_library(gfx-texture-file-obj OBJECT texture_file/texture_file.cpp)
+# add_library(gfx-texture-file-obj OBJECT texture_file/texture_file.cpp)
 #
-#   add_library(gfx-texture-file INTERFACE)
-#   target_sources(gfx-texture-file PUBLIC $<TARGET_OBJECTS:gfx-texture-file-obj>)
-#   target_link_libraries(gfx-texture-file INTERFACE gfx-texture-file-obj)
+# add_library(gfx-texture-file INTERFACE)
+# target_sources(gfx-texture-file PUBLIC $<TARGET_OBJECTS:gfx-texture-file-obj>)
+# target_link_libraries(gfx-texture-file INTERFACE gfx-texture-file-obj)
 #
 # gfx-texture-file can then be linked into a module as usual, e.g.:
-#   target_link_libraries(shards-module-gfx gfx-texture-file)
-
+# target_link_libraries(shards-module-gfx gfx-texture-file)
 function(is_module_enabled OUTPUT_VARIABLE MODULE_ID)
   if(${SHARDS_WITH_EVERYTHING})
     set(${OUTPUT_VARIABLE} TRUE PARENT_SCOPE)
@@ -207,6 +206,7 @@ function(shards_generate_rust_union TARGET_NAME)
       get_property(RUST_FEATURES TARGET ${RUST_TARGET} PROPERTY RUST_FEATURES)
       unset(RUST_FEATURES_STRING)
       unset(RUST_FEATURES_STRING1)
+
       if(RUST_FEATURES)
         unset(RUST_FEATURES_QUOTED)
 
@@ -257,6 +257,9 @@ function(shards_generate_rust_union TARGET_NAME)
     file(COPY_FILE ${CARGO_TOML}.tmp ${CARGO_TOML} ONLY_IF_DIFFERENT)
 
     unset(ENABLED_FEATURES)
+    if(TRACY_ENABLE)
+      list(APPEND ENABLED_FEATURES tracy)
+    endif()
 
     # Add the rust library
     add_rust_library(NAME ${TARGET_NAME}
@@ -311,8 +314,8 @@ function(shards_generate_union UNION_TARGET_NAME)
     )
   endif()
 
-  target_compile_definitions(${UNION_TARGET_NAME} PRIVATE 
-    SHARDS_CORE_DLL=1 
+  target_compile_definitions(${UNION_TARGET_NAME} PRIVATE
+    SHARDS_CORE_DLL=1
     shards_core_EXPORTS=1)
 
   foreach(TARGET_NAME ${SHARDS_MODULE_TARGETS})
@@ -321,6 +324,7 @@ function(shards_generate_union UNION_TARGET_NAME)
     if(UNION_EXTRA_ENABLED_MODULES)
       if(NOT "${MODULE_ID}" IN_LIST UNION_EXTRA_ENABLED_MODULES)
         message(DEBUG "Skipping module ${MODULE_ID}")
+        message(VERBOSE "Not enabled in set: ${UNION_EXTRA_ENABLED_MODULES}")
         continue()
       else()
         message(DEBUG "Including module ${MODULE_ID}")
@@ -333,10 +337,16 @@ function(shards_generate_union UNION_TARGET_NAME)
       endif()
     endif()
 
-    message(DEBUG "${UNION_TARGET_NAME}: Adding module ${TARGET_NAME} (id: ${MODULE_ID})")
-    target_link_libraries(${UNION_TARGET_NAME} ${TARGET_NAME})
     list(APPEND ENABLED_MODULE_IDS ${MODULE_ID})
     list(APPEND ENABLED_MODULE_TARGETS ${TARGET_NAME})
+
+    set(DUP_TARGET_NAME "${UNION_TARGET_NAME}_${TARGET_NAME}")
+    duplicate_library_target(${TARGET_NAME} OBJECT ${DUP_TARGET_NAME})
+    message(DEBUG "${UNION_TARGET_NAME}: Adding module ${TARGET_NAME} (as: ${DUP_TARGET_NAME}, id: ${MODULE_ID})")
+    target_link_libraries(${UNION_TARGET_NAME} ${DUP_TARGET_NAME})
+
+    # Add the generated include path to the module duplicate
+    target_include_directories(${DUP_TARGET_NAME} PUBLIC ${GENERATED_ROOT_DIR})
   endforeach()
 
   # message(STATUS "ENABLED_MODULE_IDS ${ENABLED_MODULE_IDS}")
@@ -349,7 +359,8 @@ function(shards_generate_union UNION_TARGET_NAME)
   set(GENERATED_TEMP "${CMAKE_CURRENT_BINARY_DIR}/temp.cpp")
 
   # Add include path to shards core so it can inline the code that is generated here
-  target_include_directories(shards-core PUBLIC ${GENERATED_ROOT_DIR})
+  # target_include_directories(shards-core PUBLIC ${GENERATED_ROOT_DIR})
+  target_include_directories(${UNION_TARGET_NAME} PUBLIC ${GENERATED_ROOT_DIR})
 
   file(WRITE ${GENERATED_TEMP}
     "// This file is generated by CMake\n"

cmake/Utils.cmake

@@ -1,6 +1,6 @@
 # Get all propreties that cmake supports
 if(NOT CMAKE_PROPERTIES_TO_DUPLICATE)
-  execute_process(COMMAND cmake --help-property-list OUTPUT_VARIABLE CMAKE_PROPERTIES_TO_DUPLICATE)
+  execute_process(COMMAND ${CMAKE_COMMAND} --help-property-list OUTPUT_VARIABLE CMAKE_PROPERTIES_TO_DUPLICATE)
 
   # Convert command output into a CMake list
   string(REGEX REPLACE ";" "\\\\;" CMAKE_PROPERTIES_TO_DUPLICATE "${CMAKE_PROPERTIES_TO_DUPLICATE}")
@@ -12,17 +12,21 @@ if(NOT CMAKE_PROPERTIES_TO_DUPLICATE)
     "INTERFACE_CXX_MODULE_HEADER_UNIT_SETS" "CXX_MODULE_HEADER_UNIT_SETS"
     "INTERFACE_CXX_MODULE_SETS" "CXX_MODULE_SETS"
     "BINARY_DIR" "IMPORTED" "SOURCE_DIR"
+    "MANUALLY_ADDED_DEPENDENCIES"
   )
 
   foreach(IGNORED_PROPERTY ${IGNORED_PROPERTIES})
     list(REMOVE_ITEM CMAKE_PROPERTIES_TO_DUPLICATE ${IGNORED_PROPERTY})
   endforeach()
+
+  message(VERBOSE "CMAKE_PROPERTIES_TO_DUPLICATE: ${CMAKE_PROPERTIES_TO_DUPLICATE}")
 endif()
 
 # Helper function that duplicates a library target into a new type
 # This allows defining a static library and duplicating it into a shared library target (with different defines, etc.)
 function(duplicate_library_target TARGET TYPE NEW_TARGET)
   add_library(${NEW_TARGET} ${TYPE})
+  message(VERBOSE "Duplicating library target ${TARGET} into ${NEW_TARGET} of type ${TYPE}")
 
   foreach(PROPERTY ${CMAKE_PROPERTIES_TO_DUPLICATE})
     string(REPLACE "<CONFIG>" "${CMAKE_BUILD_TYPE}" PROPERTY ${PROPERTY})
@@ -37,6 +41,7 @@ function(duplicate_library_target TARGET TYPE NEW_TARGET)
     if(IS_PROPERTY_SET)
       get_target_property(VALUE ${TARGET} ${PROPERTY})
       set_target_properties(${NEW_TARGET} PROPERTIES ${PROPERTY} "${VALUE}")
+      # message(VERBOSE "Setting ${PROPERTY} to ${VALUE}")
     endif()
   endforeach()
 

cmake/rust/union_Cargo.toml.in

@@ -6,10 +6,11 @@ version = "${CARGO_CRATE_VERSION}"
 edition = "2021"
 
 [features]
-tracy = []
+tracy = ["tracy-client"]
 
 [dependencies]
 ${CARGO_CRATE_DEPS} 
+tracy-client = { version = "0.17.4", optional = true }
 
 [patch.crates-io]
 chrono = { git = "https://github.com/shards-lang/chrono", rev = "5aaf74235778120b5984b46ced47478c1431d9a0" }
@@ -27,6 +28,8 @@ onig_sys = { git = "https://github.com/shards-lang/rust-onig.git", version = "=6
 objc = { git = "https://github.com/shards-lang/rust-objc.git", version = "=0.2.7", branch = "shards-0.2.7" }
 metal = { git = "https://github.com/shards-lang/metal-rs.git", version = "=0.29.0", branch = "shards-0.29.0" }
 
+tracy-client = { git = "https://github.com/nagisa/rust_tracy_client", tag = "tracy-client-v0.15.0" }
+
 [profile.dev.package]
 tiny-skia = { opt-level = 3 } 
 resvg = { opt-level = 3 }

include/shards/dllshard.hpp

@@ -80,6 +80,10 @@ class Core {
     return sCore._core->referenceVariable(context, name);
   }
 
+  static SHVar *findVariable(SHContext *context, struct SHStringWithLen name) {
+    return sCore._core->findVariable(context, name);
+  }
+
   static void releaseVariable(SHVar *variable) { return sCore._core->releaseVariable(variable); }
 
   static SHWireState suspend(SHContext *context, double seconds) { return sCore._core->suspend(context, seconds); }

include/shards/shards.h

@@ -878,6 +878,7 @@ typedef void(__cdecl *SHUnregisterRunLoopCallback)(SHString eventName);
 typedef void(__cdecl *SHUnregisterExitCallback)(SHString eventName);
 
 typedef struct SHVar *(__cdecl *SHReferenceVariable)(struct SHContext *context, struct SHStringWithLen name);
+typedef struct SHVar *(__cdecl *SHFindVariable)(struct SHContext *context, struct SHStringWithLen name);
 typedef struct SHVar *(__cdecl *SHReferenceWireVariable)(SHWireRef wire, struct SHStringWithLen name);
 
 typedef struct SHExternalVariable {
@@ -1292,6 +1293,8 @@ typedef struct _SHCore {
   // We never needed it before but actually useful to expose for rust and swift shards
   SHReferenceVariable referenceGlobalVariable;
 
+  SHFindVariable findVariable;
+
   //! ADD NEW FUNCTIONS AT BOTTOM OF THIS STRUCT
 } SHCore;
 

include/shards/utility.hpp

@@ -483,12 +483,12 @@ template <class SH_CORE> struct TTableVar : public SHVar {
 
   TTableVar(const TTableVar &other) : SHVar() { SH_CORE::cloneVar(*this, other); }
 
-  TTableVar(const SHVar &other) : SHVar() {
+  explicit TTableVar(const SHVar &other) : SHVar() {
     assert(other.valueType == SHType::Table);
     SH_CORE::cloneVar(*this, other);
   }
 
-  TTableVar(SHVar &&other) : SHVar() {
+  explicit TTableVar(SHVar &&other) : SHVar() {
     assert(other.valueType == SHType::Table);
     std::swap<SHVar>(*this, *reinterpret_cast<TTableVar *>(&other));
   }
@@ -710,7 +710,7 @@ template <class SH_CORE> struct TSeqVar : public SHVar {
 
   TSeqVar(TSeqVar &&other) : SHVar() { std::swap<SHVar>(*this, other); }
 
-  TSeqVar(SHVar &&other) : SHVar() {
+  explicit TSeqVar(SHVar &&other) : SHVar() {
     assert(other.valueType == SHType::Seq);
     std::swap<SHVar>(*this, other);
   }
@@ -842,6 +842,49 @@ ALWAYS_INLINE inline void assignVariableValue(SHVar &v, const SHVar &other) {
   v.version = other.version;
 }
 
+template <class SH_CORE> struct TVarOrReference {
+  const SHVar *ptr;
+  SHVar *owned = nullptr;
+
+  TVarOrReference(SHContext *context, const SHVar &v) : ptr(&v) {
+    if (v.valueType == SHType::ContextVar) {
+      if (auto var = SH_CORE::findVariable(context, toSWL(SHSTRVIEW(v)))) {
+        ptr = var;
+        owned = var;
+      } else {
+        throw std::runtime_error(fmt::format("Variable {} not found", SHSTRVIEW(v)));
+      }
+    }
+  }
+
+  TVarOrReference(SHContext *context, const char *varName) : ptr(nullptr) {
+    if (auto var = SH_CORE::findVariable(context, toSWL(varName))) {
+      ptr = var;
+      owned = var;
+    } else {
+      throw std::runtime_error(fmt::format("Variable {} not found", varName));
+    }
+  }
+
+  ~TVarOrReference() {
+    if (owned) {
+      SH_CORE::releaseVariable(const_cast<SHVar *>(owned));
+    }
+  }
+
+  TVarOrReference(const TVarOrReference &) = delete;
+  TVarOrReference &operator=(const TVarOrReference &) = delete;
+  TVarOrReference(TVarOrReference &&) = delete;
+  TVarOrReference &operator=(TVarOrReference &&) = delete;
+
+  bool isVariable() const { return owned != nullptr; }
+
+  const SHVar &get() const { return *ptr; }
+  operator const SHVar &() const { return *ptr; }
+  SHVar &get() { return const_cast<SHVar &>(*ptr); }
+  operator SHVar &() { return const_cast<SHVar &>(*ptr); }
+};
+
 }; // namespace shards
 
 // specialize hash for TOwnedVar
@@ -851,4 +894,6 @@ template <typename T> struct hash<shards::TOwnedVar<T>> {
 };
 } // namespace std
 
+template <typename SH_CORE> auto format_as(const shards::TOwnedVar<SH_CORE> &ov) { return (SHVar &)ov; }
+
 #endif

lib/hot-reload.shs

@@ -1,4 +1,3 @@
-@include("std/if.shs" Once: true)
 @define(script-hot-reload false IgnoreRedefined: true)
 
 ; Builds wrapper wires around imported hot-reloadable wires
@@ -148,8 +147,7 @@
 })
 
 @inline-template(maybe-hot-reload [script-path wires] {
-  @if-root(@script-hot-reload {
-      ; #(Log("Running hot reload macro"))
+  @if(@script-hot-reload {
       @hot-reload(@script-dir @include-dirs @namespace script-path wires)
     } {
       @include(script-path)

lib/std/if.shs

@@ -1,19 +1,35 @@
+@template(if-filter-ast [] {
+  If({ExpectTable | Take("shs") | IsSeq} {
+      ExpectTable | Take("shs")
+    } {
+      = in
+      [in]
+    }
+  )
+})
 @macro(if-root [cond yes no] {
-  @template(filter-ast [] {
-    If({ExpectTable | Take("shs") | IsSeq} {
-        ExpectTable | Take("shs")
-      } {
-        = in
-        [in]
-      }
-    )
-  })
-
-  Sequence(pipelines)
   cond | If(IsAny([true "true" 1]) {
-      @ast(yes) | FromJson | @filter-ast()
+      @ast(yes) | FromJson | @if-filter-ast()
+    } {
+      @ast(no) | FromJson | @if-filter-ast()
+    }
+  ) | ToJson
+})
+
+@macro(when [cond yes] {
+  cond | If(IsAny([true "true" 1]) {
+      @ast(yes) | FromJson | @if-filter-ast()
+    } {
+      [[]]
+    }
+  ) | ToJson
+})
+
+@macro(when-not [cond no] {
+  cond | If(IsAny([true "true" 1]) {
+      [[]]
     } {
-      @ast(no) | FromJson | @filter-ast()
+      @ast(no) | FromJson | @if-filter-ast()
     }
   ) | ToJson
 })

shards/core/check_utils.hpp

@@ -0,0 +1,25 @@
+#ifndef C25C0EEE_CC07_432E_9764_0EC84FA97064
+#define C25C0EEE_CC07_432E_9764_0EC84FA97064
+
+#include <shards/shards.hpp>
+#include "exception.hpp"
+
+namespace shards {
+inline void checkType(const SHType &type, SHType expectedType, const char *name) {
+  if (type != expectedType)
+    throw formatException("{} type should be {}, was {}", name, magic_enum::enum_name(expectedType), magic_enum::enum_name(type));
+}
+
+inline void checkEnumType(const SHVar &var, const shards::Type &expectedType, const char *name) {
+  checkType(var.valueType, SHType::Enum, name);
+  shards::Type actualType = shards::Type::Enum(var.payload.enumVendorId, var.payload.enumTypeId);
+  if (expectedType != actualType) {
+    SHTypeInfo typeInfoA = expectedType;
+    SHTypeInfo typeInfoB = actualType;
+    throw formatException("{} enum type should be {}/{}, was {}/{}", name, typeInfoA.enumeration.vendorId,
+                          typeInfoA.enumeration.typeId, typeInfoB.enumeration.vendorId, typeInfoB.enumeration.typeId);
+  }
+}
+} // namespace shards
+
+#endif /* C25C0EEE_CC07_432E_9764_0EC84FA97064 */