bless tests

Author: makspll

crates/bevy_mod_scripting_bindings/src/docgen/info.rs

@@ -229,6 +229,8 @@ variadics_please::all_tuples!(impl_documentable, 0, 13, T);
 
 #[cfg(test)]
 mod test {
+    use bevy_mod_scripting_bindings_domain::ReflectionPrimitiveKind;
+
     use crate::{
         docgen::typed_through::UntypedWrapperKind,
         function::from::{Mut, Ref, Val},
@@ -252,15 +254,15 @@ mod test {
         assert_eq!(info.arg_info[1].type_id, TypeId::of::<f32>());
 
         match info.arg_info[0].type_info.as_ref().unwrap() {
-            ThroughTypeInfo::TypeInfo(type_info) => {
-                assert_eq!(type_info.type_id(), TypeId::of::<i32>());
+            ThroughTypeInfo::Primitive(prim) => {
+                assert_eq!(*prim, ReflectionPrimitiveKind::I32);
             }
             _ => panic!("Expected TypeInfo"),
         }
 
         match info.arg_info[1].type_info.as_ref().unwrap() {
-            ThroughTypeInfo::TypeInfo(type_info) => {
-                assert_eq!(type_info.type_id(), TypeId::of::<f32>());
+            ThroughTypeInfo::Primitive(prim) => {
+                assert_eq!(*prim, ReflectionPrimitiveKind::F32);
             }
             _ => panic!("Expected TypeInfo"),
         }

crates/bevy_mod_scripting_bindings/src/docgen/typed_through.rs

@@ -342,80 +342,54 @@ variadics_please::all_tuples!(impl_through_typed_tuple, 0, 13, T);
 mod test {
     use super::*;
 
-    fn assert_type_info_is_through<T: Typed + TypedThrough>() {
+    fn assert_type_info_is_primitive<T: Typed + TypedThrough>(kind: ReflectionPrimitiveKind) {
         let type_info = T::type_info();
         let through_type_info = T::through_type_info();
-
-        match through_type_info {
-            ThroughTypeInfo::TypeInfo(info) => {
-                assert_eq!(info.type_id(), type_info.type_id());
-                assert_eq!(info.type_path(), type_info.type_path());
-            }
-            _ => panic!("Expected ThroughTypeInfo::TypeInfo"),
-        }
-    }
-
-    fn assert_dynamic_through_type_is_val_info<T: Typed + TypedThrough>() {
-        let type_info = T::type_info();
-        let through_type_info = into_through_type_info(type_info);
-
-        match through_type_info {
-            ThroughTypeInfo::UntypedWrapper {
-                through_type,
-                wrapper_kind,
-            } => {
-                assert_eq!(wrapper_kind, UntypedWrapperKind::Val);
-                assert_eq!(through_type.type_id(), type_info.type_id());
-                assert_eq!(through_type.type_path(), type_info.type_path());
+        let dynamic_through_type_info = into_through_type_info(type_info);
+
+        for (test, info) in [
+            ("static", through_type_info),
+            ("dynamic", dynamic_through_type_info),
+        ] {
+            match info {
+                ThroughTypeInfo::Primitive(prim) => {
+                    assert_eq!(
+                        prim,
+                        kind,
+                        "expected {} to have primitive {test} type info: {kind}",
+                        std::any::type_name::<T>()
+                    )
+                }
+                _ => panic!("Expected ThroughTypeInfo::TypeInfo"),
             }
-            _ => panic!("Expected ThroughTypeInfo::TypeInfo"),
         }
     }
 
     #[test]
     fn test_typed_through_primitives() {
-        assert_type_info_is_through::<bool>();
-        assert_dynamic_through_type_is_val_info::<bool>();
-        assert_type_info_is_through::<i8>();
-        assert_dynamic_through_type_is_val_info::<i8>();
-        assert_type_info_is_through::<i16>();
-        assert_dynamic_through_type_is_val_info::<i16>();
-        assert_type_info_is_through::<i32>();
-        assert_dynamic_through_type_is_val_info::<i32>();
-        assert_type_info_is_through::<i64>();
-        assert_dynamic_through_type_is_val_info::<i64>();
-        assert_type_info_is_through::<i128>();
-        assert_dynamic_through_type_is_val_info::<i128>();
-        assert_type_info_is_through::<u8>();
-        assert_dynamic_through_type_is_val_info::<u8>();
-        assert_type_info_is_through::<u16>();
-        assert_dynamic_through_type_is_val_info::<u16>();
-        assert_type_info_is_through::<u32>();
-        assert_dynamic_through_type_is_val_info::<u32>();
-        assert_type_info_is_through::<u64>();
-        assert_dynamic_through_type_is_val_info::<u64>();
-        assert_type_info_is_through::<u128>();
-        assert_dynamic_through_type_is_val_info::<u128>();
-        assert_type_info_is_through::<f32>();
-        assert_dynamic_through_type_is_val_info::<f32>();
-        assert_type_info_is_through::<f64>();
-        assert_dynamic_through_type_is_val_info::<f64>();
-        assert_type_info_is_through::<usize>();
-        assert_dynamic_through_type_is_val_info::<usize>();
-        assert_type_info_is_through::<isize>();
-        assert_dynamic_through_type_is_val_info::<isize>();
-        assert_type_info_is_through::<String>();
-        assert_dynamic_through_type_is_val_info::<String>();
-        assert_type_info_is_through::<PathBuf>();
-        assert_dynamic_through_type_is_val_info::<PathBuf>();
-        assert_type_info_is_through::<OsString>();
-        assert_dynamic_through_type_is_val_info::<OsString>();
-        assert_type_info_is_through::<char>();
-        assert_dynamic_through_type_is_val_info::<char>();
-        assert_type_info_is_through::<ReflectReference>();
-        assert_dynamic_through_type_is_val_info::<ReflectReference>();
-        assert_type_info_is_through::<&'static str>();
-        assert_dynamic_through_type_is_val_info::<&'static str>();
+        assert_type_info_is_primitive::<bool>(ReflectionPrimitiveKind::Bool);
+        assert_type_info_is_primitive::<i8>(ReflectionPrimitiveKind::I8);
+        assert_type_info_is_primitive::<i16>(ReflectionPrimitiveKind::I16);
+        assert_type_info_is_primitive::<i32>(ReflectionPrimitiveKind::I32);
+        assert_type_info_is_primitive::<i64>(ReflectionPrimitiveKind::I64);
+        assert_type_info_is_primitive::<i128>(ReflectionPrimitiveKind::I128);
+        assert_type_info_is_primitive::<u8>(ReflectionPrimitiveKind::U8);
+        assert_type_info_is_primitive::<u16>(ReflectionPrimitiveKind::U16);
+        assert_type_info_is_primitive::<u32>(ReflectionPrimitiveKind::U32);
+        assert_type_info_is_primitive::<u64>(ReflectionPrimitiveKind::U64);
+        assert_type_info_is_primitive::<u128>(ReflectionPrimitiveKind::U128);
+        assert_type_info_is_primitive::<f32>(ReflectionPrimitiveKind::F32);
+        assert_type_info_is_primitive::<f64>(ReflectionPrimitiveKind::F64);
+        assert_type_info_is_primitive::<usize>(ReflectionPrimitiveKind::Usize);
+        assert_type_info_is_primitive::<isize>(ReflectionPrimitiveKind::Isize);
+        assert_type_info_is_primitive::<String>(ReflectionPrimitiveKind::String);
+        assert_type_info_is_primitive::<PathBuf>(ReflectionPrimitiveKind::PathBuf);
+        assert_type_info_is_primitive::<OsString>(ReflectionPrimitiveKind::OsString);
+        assert_type_info_is_primitive::<char>(ReflectionPrimitiveKind::Char);
+        assert_type_info_is_primitive::<ReflectReference>(
+            ReflectionPrimitiveKind::ReflectReference,
+        );
+        assert_type_info_is_primitive::<&'static str>(ReflectionPrimitiveKind::Str);
     }
 
     #[test]

crates/lad_backends/lua_language_server_lad_backend/tests/example_ladfile/expected.lua

@@ -1,40 +1,161 @@
 ---@meta
 ---@module "PlainStructType"
 
----@class PlainStructType
+---@class PlainStructType : ReflectReference
 ---  I am a simple plain struct type
 ---@field  int_field ? integer
 PlainStructType = {}
 
----@package
 ---@param p1 PlainStructType 
-
 ---@param p2 integer 
-
 ---@return any
 function PlainStructType:plain_struct_function(p1,p2) end
 
 
----@class EnumType
+---@class Bool
+--- A boolean value
+Bool = {}
+
+
+---@class Char
+--- An 8-bit character
+Char = {}
+
+
+---@class DynamicFunction
+--- A callable dynamic function
+DynamicFunction = {}
+
+
+---@class DynamicFunctionMut
+--- A stateful and callable dynamic function
+DynamicFunctionMut = {}
+
+
+---@class F32
+--- A 32-bit floating point number
+F32 = {}
+
+
+---@class F64
+--- A 64-bit floating point number
+F64 = {}
+
+
+---@class FunctionCallContext
+--- Function call context, if accepted by a function, means the function can access the world in arbitrary ways.
+FunctionCallContext = {}
+
+
+---@class I128
+--- A signed 128-bit integer
+I128 = {}
+
+
+---@class I16
+--- A signed 16-bit integer
+I16 = {}
+
+
+---@class I32
+--- A signed 32-bit integer
+I32 = {}
+
+
+---@class I64
+--- A signed 64-bit integer
+I64 = {}
+
+
+---@class I8
+--- A signed 8-bit integer
+I8 = {}
+
+
+---@class Isize
+--- A signed pointer-sized integer
+Isize = {}
+
+
+---@class OsString
+--- A heap allocated OS string
+OsString = {}
+
+
+---@class PathBuf
+--- A heap allocated file path
+PathBuf = {}
+
+
+---@class ReflectReference
+--- A reference to a reflectable type
+ReflectReference = {}
+
+
+---@class ScriptValue
+--- A value representing the union of all representable values
+ScriptValue = {}
+
+
+---@class Str
+--- A string slice
+Str = {}
+
+
+---@class String
+--- A heap allocated string
+String = {}
+
+
+---@class U128
+--- An unsigned 128-bit integer
+U128 = {}
+
+
+---@class U16
+--- An unsigned 16-bit integer
+U16 = {}
+
+
+---@class U32
+--- An unsigned 32-bit integer
+U32 = {}
+
+
+---@class U64
+--- An unsigned 64-bit integer
+U64 = {}
+
+
+---@class U8
+--- An unsigned 8-bit integer
+U8 = {}
+
+
+---@class Usize
+--- An unsigned pointer-sized integer
+Usize = {}
+
 
+---@class EnumType : ReflectReference
 EnumType = {}
 
 
----@class TupleStructType
+---@class TupleStructType : ReflectReference
 ---  I am a tuple test type
----@field  [1] ? integer
----@field  [2] ? string
+---@field  [1]  integer
+---@field  [2]  string
 TupleStructType = {}
 
 
----@class UnitType
+---@class UnitType : ReflectReference
 ---  I am a unit test type
 UnitType = {}
 
 
 
 
----@type GenericStructType
+---@type any
 --- A static class allowing calls through the "." operator only. 
 my_static_instance = {}
 

crates/lad_backends/lua_language_server_lad_backend/tests/integration_tests.rs

@@ -82,6 +82,7 @@ fn main() {
             if std::env::var("BLESS_MODE").is_ok() {
                 std::fs::write(&expected_path, &generated_str)
                     .expect("failed to write expected.lua file");
+                panic!("BLESS_MODE is enabled, please disable it to run the tests");
             } else {
                 pretty_assertions::assert_eq!(
                     expected_str,
@@ -92,7 +93,4 @@ fn main() {
             }
         }
     }
-    if std::env::var("BLESS_MODE").is_ok() {
-        panic!("BLESS_MODE is enabled, please disable it to run the tests");
-    }
 }