From e09625a0c0165914d3ab135a21e664a6ac8ad86c Mon Sep 17 00:00:00 2001 From: doonv <58695417+doonv@users.noreply.github.com> Date: Sat, 28 Dec 2024 19:21:54 +0200 Subject: [PATCH 1/5] compiling but had to remove some reflection features --- Cargo.toml | 7 +- src/builtin_parser/runner.rs | 316 +++++++++---------- src/builtin_parser/runner/reflection.rs | 11 +- src/builtin_parser/runner/value.rs | 386 ++++++++++++------------ src/ui.rs | 2 +- src/ui/completions.rs | 2 +- 6 files changed, 364 insertions(+), 360 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 88f3db6..6fbaa60 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,19 +23,20 @@ builtin-parser = ["dep:logos"] [dependencies] # This crate by itself doesn't use any bevy features, but `bevy_egui` (dep) uses "bevy_asset". -bevy = { version = "0.14.0", default-features = false, features = [] } -bevy_egui = "0.28.0" +bevy = { version = "0.15.0", default-features = false, features = [] } +bevy_egui = "0.31.1" chrono = "0.4.31" tracing-log = "0.2.0" tracing-subscriber = "0.3.18" web-time = "1.0.0" +winit = "0.30.5" # builtin-parser features logos = { version = "0.14.0", optional = true } fuzzy-matcher = { version = "0.3.7", optional = true } [dev-dependencies] -bevy = "0.14.0" +bevy = "0.15.0" [lints] clippy.useless_format = "allow" diff --git a/src/builtin_parser/runner.rs b/src/builtin_parser/runner.rs index 1146605..e05b943 100644 --- a/src/builtin_parser/runner.rs +++ b/src/builtin_parser/runner.rs @@ -220,164 +220,164 @@ fn eval_expression( .reflect_path_mut(resource.path.as_str()) .unwrap(); - match reflect.reflect_mut() { - ReflectMut::Enum(dyn_enum) => { - let TypeInfo::Enum(enum_info) = registration.type_info() else { - unreachable!() - }; - let Spanned { span, value } = *value_expr; - match value { - Expression::Variable(name) => { - let variant_info = match enum_info.variant(&name) { - Some(variant_info) => variant_info, - None => { - return Err(EvalError::EnumVariantNotFound(span.wrap(name))) - } - }; - let VariantInfo::Unit(_) = variant_info else { - return todo_error!("{variant_info:?}"); - }; - - let new_enum = DynamicEnum::new(name, ()); - - dyn_enum.apply(&new_enum); - } - Expression::StructObject { name, map } => { - let variant_info = match enum_info.variant(&name) { - Some(variant_info) => variant_info, - None => { - return Err(EvalError::EnumVariantNotFound(span.wrap(name))) - } - }; - let VariantInfo::Struct(variant_info) = variant_info else { - return todo_error!("{variant_info:?}"); - }; - - let map: HashMap<_, _> = map - .into_iter() - .map(|(k, v)| { - let ty = match variant_info.field(&k) { - Some(field) => Ok(field.type_path_table().short_path()), - None => { - Err(EvalError::EnumVariantStructFieldNotFound { - field_name: k.clone(), - variant_name: name.clone(), - span: span.clone(), - }) - } - }?; - - let span = v.span.clone(); - - Ok(( - k, - ( - eval_expression( - v, - EvalParams { - world, - environment, - registrations, - }, - )?, - span, - ty, - ), - )) - }) - .collect::>()?; - - let new_enum = - DynamicEnum::new(name, object_to_dynamic_struct(map)?); - - let mut dyn_reflect = - resource.mut_dyn_reflect(world, registrations); - - let dyn_enum = dyn_reflect - .reflect_path_mut(resource.path.as_str()) - .unwrap(); - - dyn_enum.apply(&new_enum); - } - Expression::StructTuple { name, tuple } => { - let variant_info = match enum_info.variant(&name) { - Some(variant_info) => variant_info, - None => { - return Err(EvalError::EnumVariantNotFound(span.wrap(name))) - } - }; - let VariantInfo::Tuple(variant_info) = variant_info else { - return todo_error!("{variant_info:?}"); - }; - - let tuple = eval_tuple( - tuple, - EvalParams { - world, - environment, - registrations, - }, - )?; - - let mut dynamic_tuple = DynamicTuple::default(); - - for (index, element) in tuple.into_vec().into_iter().enumerate() { - let ty = match variant_info.field_at(index) { - Some(field) => Ok(field.type_path_table().short_path()), - None => Err(EvalError::EnumVariantTupleFieldNotFound { - field_index: index, - variant_name: name.clone(), - span: span.clone(), - }), - }?; - - dynamic_tuple.insert_boxed( - element.value.into_inner().reflect(element.span, ty)?, - ); - } - - let new_enum = DynamicEnum::new(name, dynamic_tuple); - - let mut dyn_reflect = - resource.mut_dyn_reflect(world, registrations); - - let dyn_enum = dyn_reflect - .reflect_path_mut(resource.path.as_str()) - .unwrap(); - - dyn_enum.apply(&new_enum); - } - _ => todo_error!(), - } - } - _ => { - let span = value_expr.span.clone(); - let ty = reflect.reflect_short_type_path().to_owned(); - let value = eval_expression( - *value_expr, - EvalParams { - world, - environment, - registrations, - }, - )?; - let value_reflect = value.reflect(span.clone(), &ty)?; - - let mut dyn_reflect = resource.mut_dyn_reflect(world, registrations); - - let reflect = dyn_reflect - .reflect_path_mut(resource.path.as_str()) - .unwrap(); - - reflect.set(value_reflect).map_err(|value_reflect| { - EvalError::IncompatibleReflectTypes { - span, - expected: reflect.reflect_type_path().to_string(), - actual: value_reflect.reflect_type_path().to_string(), - } - })?; - } - } + // match reflect.reflect_mut() { + // ReflectMut::Enum(dyn_enum) => { + // let TypeInfo::Enum(enum_info) = registration.type_info() else { + // unreachable!() + // }; + // let Spanned { span, value } = *value_expr; + // match value { + // Expression::Variable(name) => { + // let variant_info = match enum_info.variant(&name) { + // Some(variant_info) => variant_info, + // None => { + // return Err(EvalError::EnumVariantNotFound(span.wrap(name))) + // } + // }; + // let VariantInfo::Unit(_) = variant_info else { + // return todo_error!("{variant_info:?}"); + // }; + + // let new_enum = DynamicEnum::new(name, ()); + + // dyn_enum.apply(&new_enum); + // } + // Expression::StructObject { name, map } => { + // let variant_info = match enum_info.variant(&name) { + // Some(variant_info) => variant_info, + // None => { + // return Err(EvalError::EnumVariantNotFound(span.wrap(name))) + // } + // }; + // let VariantInfo::Struct(variant_info) = variant_info else { + // return todo_error!("{variant_info:?}"); + // }; + + // let map: HashMap<_, _> = map + // .into_iter() + // .map(|(k, v)| { + // let ty = match variant_info.field(&k) { + // Some(field) => Ok(field.type_path_table().short_path()), + // None => { + // Err(EvalError::EnumVariantStructFieldNotFound { + // field_name: k.clone(), + // variant_name: name.clone(), + // span: span.clone(), + // }) + // } + // }?; + + // let span = v.span.clone(); + + // Ok(( + // k, + // ( + // eval_expression( + // v, + // EvalParams { + // world, + // environment, + // registrations, + // }, + // )?, + // span, + // ty, + // ), + // )) + // }) + // .collect::>()?; + + // let new_enum = + // DynamicEnum::new(name, object_to_dynamic_struct(map)?); + + // let mut dyn_reflect = + // resource.mut_dyn_reflect(world, registrations); + + // let dyn_enum = dyn_reflect + // .reflect_path_mut(resource.path.as_str()) + // .unwrap(); + + // dyn_enum.apply(&new_enum); + // } + // Expression::StructTuple { name, tuple } => { + // let variant_info = match enum_info.variant(&name) { + // Some(variant_info) => variant_info, + // None => { + // return Err(EvalError::EnumVariantNotFound(span.wrap(name))) + // } + // }; + // let VariantInfo::Tuple(variant_info) = variant_info else { + // return todo_error!("{variant_info:?}"); + // }; + + // let tuple = eval_tuple( + // tuple, + // EvalParams { + // world, + // environment, + // registrations, + // }, + // )?; + + // let mut dynamic_tuple = DynamicTuple::default(); + + // for (index, element) in tuple.into_vec().into_iter().enumerate() { + // let ty = match variant_info.field_at(index) { + // Some(field) => Ok(field.type_path_table().short_path()), + // None => Err(EvalError::EnumVariantTupleFieldNotFound { + // field_index: index, + // variant_name: name.clone(), + // span: span.clone(), + // }), + // }?; + + // dynamic_tuple.insert_boxed( + // element.value.into_inner().reflect(element.span, ty)?.into_partial_reflect(), + // ); + // } + + // let new_enum = DynamicEnum::new(name, dynamic_tuple); + + // let mut dyn_reflect = + // resource.mut_dyn_reflect(world, registrations); + + // let dyn_enum = dyn_reflect + // .reflect_path_mut(resource.path.as_str()) + // .unwrap(); + + // dyn_enum.apply(&new_enum); + // } + // _ => todo_error!(), + // } + // } + // _ => { + // let span = value_expr.span.clone(); + // let ty = reflect.reflect_short_type_path().to_owned(); + // let value = eval_expression( + // *value_expr, + // EvalParams { + // world, + // environment, + // registrations, + // }, + // )?; + // let value_reflect = value.reflect(span.clone(), &ty)?; + + // let mut dyn_reflect = resource.mut_dyn_reflect(world, registrations); + + // let reflect = dyn_reflect + // .reflect_path_mut(resource.path.as_str()) + // .unwrap(); + + // reflect.set(value_reflect).map_err(|value_reflect| { + // EvalError::IncompatibleReflectTypes { + // span, + // expected: reflect.reflect_type_path().to_string(), + // actual: value_reflect.reflect_type_path().to_string(), + // } + // })?; + // } + // } Ok(Value::Resource(resource)) } diff --git a/src/builtin_parser/runner/reflection.rs b/src/builtin_parser/runner/reflection.rs index 2114f5d..c107c75 100644 --- a/src/builtin_parser/runner/reflection.rs +++ b/src/builtin_parser/runner/reflection.rs @@ -48,13 +48,14 @@ impl IntoResource { pub fn object_to_dynamic_struct( hashmap: HashMap, ) -> Result { - let mut dynamic_struct = DynamicStruct::default(); + todo!() + // let mut dynamic_struct = DynamicStruct::default(); - for (key, (value, span, reflect)) in hashmap { - dynamic_struct.insert_boxed(&key, value.reflect(span, reflect)?); - } + // for (key, (value, span, reflect)) in hashmap { + // dynamic_struct.insert_boxed(&key, value.reflect(span, reflect)?); + // } - Ok(dynamic_struct) + // Ok(dynamic_struct) } pub fn mut_dyn_reflect<'a>( diff --git a/src/builtin_parser/runner/value.rs b/src/builtin_parser/runner/value.rs index 711ed3a..791976b 100644 --- a/src/builtin_parser/runner/value.rs +++ b/src/builtin_parser/runner/value.rs @@ -65,32 +65,33 @@ impl Value { /// /// `ty` is used for type inference. pub fn reflect(self, span: Span, ty: &str) -> Result, EvalError> { - match self { - Value::None => Ok(Box::new(())), - Value::Number(number) => number.reflect(span, ty), - Value::Boolean(boolean) => Ok(Box::new(boolean)), - Value::String(string) => Ok(Box::new(string)), - Value::Reference(_reference) => Err(EvalError::CannotReflectReference(span)), - Value::Object(object) | Value::StructObject { map: object, .. } => { - let mut dyn_struct = DynamicStruct::default(); - - for (name, value) in object { - dyn_struct.insert_boxed(&name, value.into_inner().reflect(span.clone(), ty)?); - } - - Ok(Box::new(dyn_struct)) - } - Value::Tuple(tuple) | Value::StructTuple { tuple, .. } => { - let mut dyn_tuple = DynamicTuple::default(); - - for element in Vec::from(tuple).into_iter() { - dyn_tuple.insert_boxed(element.value.into_inner().reflect(element.span, ty)?); - } - - Ok(Box::new(dyn_tuple)) - } - Value::Resource(_) => Err(EvalError::CannotReflectResource(span)), - } + todo!() + // match self { + // Value::None => Ok(Box::new(())), + // Value::Number(number) => number.reflect(span, ty), + // Value::Boolean(boolean) => Ok(Box::new(boolean)), + // Value::String(string) => Ok(Box::new(string)), + // Value::Reference(_reference) => Err(EvalError::CannotReflectReference(span)), + // Value::Object(object) | Value::StructObject { map: object, .. } => { + // let mut dyn_struct = DynamicStruct::default(); + + // for (name, value) in object { + // dyn_struct.insert_boxed(&name, value.into_inner().reflect(span.clone(), ty)?); + // } + + // Ok(Box::new(dyn_struct)) + // } + // Value::Tuple(tuple) | Value::StructTuple { tuple, .. } => { + // let mut dyn_tuple = DynamicTuple::default(); + + // for element in Vec::from(tuple).into_iter() { + // dyn_tuple.insert_boxed(element.value.into_inner().reflect(element.span, ty)?); + // } + + // Ok(Box::new(dyn_tuple)) + // } + // Value::Resource(_) => Err(EvalError::CannotReflectResource(span)), + // } } /// Attempts to format this [`Value`]. @@ -240,172 +241,173 @@ fn fancy_debug_print( registrations: &[&TypeRegistration], ) -> String { const TAB: &str = " "; - let registration = registrations.create_registration(resource.id); - let dyn_reflect = resource.ref_dyn_reflect(world, registration); - - let reflect = dyn_reflect.reflect_path(resource.path.as_str()).unwrap(); - - fn debug_subprint(reflect: &dyn Reflect, indentation: usize) -> String { - let mut f = String::new(); - let reflect_ref = reflect.reflect_ref(); - let indentation_string = TAB.repeat(indentation); - match reflect_ref { - ReflectRef::Struct(struct_info) => { - f += "{\n"; - for i in 0..struct_info.field_len() { - let field = struct_info.field_at(i).unwrap(); - let field_name = struct_info.name_at(i).unwrap(); - - let field_value = debug_subprint(field, indentation + 1); - f += &format!( - "{indentation_string}{TAB}{field_name}: {} = {field_value},\n", - field.reflect_short_type_path(), - ); - } - f += &indentation_string; - f += "}"; - } - ReflectRef::TupleStruct(_) => todo!(), - ReflectRef::Tuple(tuple_info) => { - f += "(\n"; - for field in tuple_info.iter_fields() { - let field_value = debug_subprint(field, indentation + 1); - f += &format!("{indentation_string}{TAB}{field_value},\n",); - } - f += &indentation_string; - f += ")"; - } - ReflectRef::List(_) => todo!(), - ReflectRef::Array(_) => todo!(), - ReflectRef::Map(_) => todo!(), - ReflectRef::Enum(variant) => { - // Print out the enum types - f += variant.variant_name(); - - match variant.variant_type() { - VariantType::Struct => { - f += " {\n"; - for field in variant.iter_fields() { - f += &format!( - "{indentation_string}{TAB}{}: {} = {},\n", - field.name().unwrap(), - field.value().reflect_short_type_path(), - debug_subprint(field.value(), indentation + 1) - ); - } - f += &indentation_string; - f += "}"; - } - VariantType::Tuple => { - f += "(\n"; - for field in variant.iter_fields() { - f += &format!( - "{indentation_string}{TAB}{} = {},\n", - field.value().reflect_short_type_path(), - debug_subprint(field.value(), indentation + 1) - ); - } - f += &indentation_string; - f += ")"; - } - VariantType::Unit => {} - } - } - ReflectRef::Value(_) => { - f += &format!("{reflect:?}"); - } - } - - f - } - - let mut f = String::new(); - let reflect_ref = reflect.reflect_ref(); - match reflect_ref { - ReflectRef::Struct(struct_info) => { - f += &format!("struct {} {{\n", struct_info.reflect_short_type_path()); - for i in 0..struct_info.field_len() { - let field = struct_info.field_at(i).unwrap(); - let field_name = struct_info.name_at(i).unwrap(); - - let field_value = debug_subprint(field, 1); - f += &format!( - "{TAB}{}: {} = {},\n", - field_name, - field.reflect_short_type_path(), - field_value - ); - } - f += "}"; - } - ReflectRef::TupleStruct(_) => todo!(), - ReflectRef::Tuple(_) => todo!(), - ReflectRef::List(_) => todo!(), - ReflectRef::Array(_) => todo!(), - ReflectRef::Map(_) => todo!(), - ReflectRef::Enum(set_variant_info) => { - // Print out the enum types - f += &format!("enum {} {{\n", set_variant_info.reflect_short_type_path()); - let TypeInfo::Enum(enum_info) = registration.type_info() else { - unreachable!() - }; - for variant in enum_info.iter() { - f += "\t"; - f += variant.name(); - match variant { - VariantInfo::Struct(variant) => { - f += " {\n"; - for field in variant.iter() { - f += &format!( - "{TAB}{TAB}{}: {},\n", - field.name(), - field.type_path_table().short_path() - ); - } - f += TAB; - f += "}"; - } - VariantInfo::Tuple(variant) => { - f += "("; - let mut iter = variant.iter(); - if let Some(first) = iter.next() { - f += &format!("{}", first.type_path_table().short_path()); - for field in iter { - f += &format!(", {}", field.type_path_table().short_path()); - } - } - f += ")"; - } - VariantInfo::Unit(_) => {} - } - f += ",\n"; - } - // Print out the current value - f += "} = "; - f += set_variant_info.variant_name(); - match set_variant_info.variant_type() { - VariantType::Struct => { - f += " {\n"; - for field in set_variant_info.iter_fields() { - f += &format!("{TAB}{}: {:?},\n", field.name().unwrap(), field.value()); - } - f += "}"; - } - VariantType::Tuple => { - f += "(\n"; - for field in set_variant_info.iter_fields() { - f += &format!("{TAB}{:?},\n", field.value()); - } - f += ")"; - } - VariantType::Unit => {} - } - } - ReflectRef::Value(value) => { - f += &format!("{value:?}"); - } - } - f + todo!() + // let registration = registrations.create_registration(resource.id); + // let dyn_reflect = resource.ref_dyn_reflect(world, registration); + + // let reflect = dyn_reflect.reflect_path(resource.path.as_str()).unwrap(); + + // fn debug_subprint(reflect: &dyn Reflect, indentation: usize) -> String { + // let mut f = String::new(); + // let reflect_ref = reflect.reflect_ref(); + // let indentation_string = TAB.repeat(indentation); + // match reflect_ref { + // ReflectRef::Struct(struct_info) => { + // f += "{\n"; + // for i in 0..struct_info.field_len() { + // let field = struct_info.field_at(i).unwrap(); + // let field_name = struct_info.name_at(i).unwrap(); + + // let field_value = debug_subprint(field, indentation + 1); + // f += &format!( + // "{indentation_string}{TAB}{field_name}: {} = {field_value},\n", + // field.reflect_short_type_path(), + // ); + // } + // f += &indentation_string; + // f += "}"; + // } + // ReflectRef::TupleStruct(_) => todo!(), + // ReflectRef::Tuple(tuple_info) => { + // f += "(\n"; + // for field in tuple_info.iter_fields() { + // let field_value = debug_subprint(field, indentation + 1); + // f += &format!("{indentation_string}{TAB}{field_value},\n",); + // } + // f += &indentation_string; + // f += ")"; + // } + // ReflectRef::List(_) => todo!(), + // ReflectRef::Array(_) => todo!(), + // ReflectRef::Map(_) => todo!(), + // ReflectRef::Enum(variant) => { + // // Print out the enum types + // f += variant.variant_name(); + + // match variant.variant_type() { + // VariantType::Struct => { + // f += " {\n"; + // for field in variant.iter_fields() { + // f += &format!( + // "{indentation_string}{TAB}{}: {} = {},\n", + // field.name().unwrap(), + // field.value().reflect_short_type_path(), + // debug_subprint(field.value(), indentation + 1) + // ); + // } + // f += &indentation_string; + // f += "}"; + // } + // VariantType::Tuple => { + // f += "(\n"; + // for field in variant.iter_fields() { + // f += &format!( + // "{indentation_string}{TAB}{} = {},\n", + // field.value().reflect_short_type_path(), + // debug_subprint(field.value(), indentation + 1) + // ); + // } + // f += &indentation_string; + // f += ")"; + // } + // VariantType::Unit => {} + // } + // } + // ReflectRef::Value(_) => { + // f += &format!("{reflect:?}"); + // } + // } + + // f + // } + + // let mut f = String::new(); + // let reflect_ref = reflect.reflect_ref(); + // match reflect_ref { + // ReflectRef::Struct(struct_info) => { + // f += &format!("struct {} {{\n", struct_info.reflect_short_type_path()); + // for i in 0..struct_info.field_len() { + // let field = struct_info.field_at(i).unwrap(); + // let field_name = struct_info.name_at(i).unwrap(); + + // let field_value = debug_subprint(field, 1); + // f += &format!( + // "{TAB}{}: {} = {},\n", + // field_name, + // field.reflect_short_type_path(), + // field_value + // ); + // } + // f += "}"; + // } + // ReflectRef::TupleStruct(_) => todo!(), + // ReflectRef::Tuple(_) => todo!(), + // ReflectRef::List(_) => todo!(), + // ReflectRef::Array(_) => todo!(), + // ReflectRef::Map(_) => todo!(), + // ReflectRef::Enum(set_variant_info) => { + // // Print out the enum types + // f += &format!("enum {} {{\n", set_variant_info.reflect_short_type_path()); + // let TypeInfo::Enum(enum_info) = registration.type_info() else { + // unreachable!() + // }; + // for variant in enum_info.iter() { + // f += "\t"; + // f += variant.name(); + // match variant { + // VariantInfo::Struct(variant) => { + // f += " {\n"; + // for field in variant.iter() { + // f += &format!( + // "{TAB}{TAB}{}: {},\n", + // field.name(), + // field.type_path_table().short_path() + // ); + // } + // f += TAB; + // f += "}"; + // } + // VariantInfo::Tuple(variant) => { + // f += "("; + // let mut iter = variant.iter(); + // if let Some(first) = iter.next() { + // f += &format!("{}", first.type_path_table().short_path()); + // for field in iter { + // f += &format!(", {}", field.type_path_table().short_path()); + // } + // } + // f += ")"; + // } + // VariantInfo::Unit(_) => {} + // } + // f += ",\n"; + // } + // // Print out the current value + // f += "} = "; + // f += set_variant_info.variant_name(); + // match set_variant_info.variant_type() { + // VariantType::Struct => { + // f += " {\n"; + // for field in set_variant_info.iter_fields() { + // f += &format!("{TAB}{}: {:?},\n", field.name().unwrap(), field.value()); + // } + // f += "}"; + // } + // VariantType::Tuple => { + // f += "(\n"; + // for field in set_variant_info.iter_fields() { + // f += &format!("{TAB}{:?},\n", field.value()); + // } + // f += ")"; + // } + // VariantType::Unit => {} + // } + // } + // ReflectRef::Value(value) => { + // f += &format!("{value:?}"); + // } + // } + // f } impl From<()> for Value { diff --git a/src/ui.rs b/src/ui.rs index aa859d5..fed5d90 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -117,7 +117,7 @@ pub fn render_ui( info!(name: COMMAND_MESSAGE_NAME, "{COMMAND_MESSAGE_PREFIX}{}", command.trim()); // Get the owned command string by replacing it with an empty string let command = std::mem::take(command); - commands.add(ExecuteCommand(command)); + commands.queue(ExecuteCommand(command)); } } diff --git a/src/ui/completions.rs b/src/ui/completions.rs index 208cc13..026a512 100644 --- a/src/ui/completions.rs +++ b/src/ui/completions.rs @@ -60,7 +60,7 @@ pub fn completions( // If not found, the whole substring is a word None => before_cursor, }; - commands.add(UpdateAutoComplete(keyword_before.to_owned())); + commands.queue(UpdateAutoComplete(keyword_before.to_owned())); } else { ui.memory_mut(|mem| { if mem.is_popup_open(text_edit_complete_id) { From 6d41108a2f3373f155bbc9b3a6c2ed8226b2494c Mon Sep 17 00:00:00 2001 From: doonv <58695417+doonv@users.noreply.github.com> Date: Sun, 29 Dec 2024 16:50:55 +0200 Subject: [PATCH 2/5] it works now --- src/builtin_parser/runner.rs | 313 +++++++++--------- src/builtin_parser/runner/environment.rs | 10 +- src/builtin_parser/runner/error.rs | 9 + src/builtin_parser/runner/value.rs | 395 +++++++++++------------ 4 files changed, 365 insertions(+), 362 deletions(-) diff --git a/src/builtin_parser/runner.rs b/src/builtin_parser/runner.rs index e05b943..500efcf 100644 --- a/src/builtin_parser/runner.rs +++ b/src/builtin_parser/runner.rs @@ -220,164 +220,160 @@ fn eval_expression( .reflect_path_mut(resource.path.as_str()) .unwrap(); - // match reflect.reflect_mut() { - // ReflectMut::Enum(dyn_enum) => { - // let TypeInfo::Enum(enum_info) = registration.type_info() else { - // unreachable!() - // }; - // let Spanned { span, value } = *value_expr; - // match value { - // Expression::Variable(name) => { - // let variant_info = match enum_info.variant(&name) { - // Some(variant_info) => variant_info, - // None => { - // return Err(EvalError::EnumVariantNotFound(span.wrap(name))) - // } - // }; - // let VariantInfo::Unit(_) = variant_info else { - // return todo_error!("{variant_info:?}"); - // }; - - // let new_enum = DynamicEnum::new(name, ()); - - // dyn_enum.apply(&new_enum); - // } - // Expression::StructObject { name, map } => { - // let variant_info = match enum_info.variant(&name) { - // Some(variant_info) => variant_info, - // None => { - // return Err(EvalError::EnumVariantNotFound(span.wrap(name))) - // } - // }; - // let VariantInfo::Struct(variant_info) = variant_info else { - // return todo_error!("{variant_info:?}"); - // }; - - // let map: HashMap<_, _> = map - // .into_iter() - // .map(|(k, v)| { - // let ty = match variant_info.field(&k) { - // Some(field) => Ok(field.type_path_table().short_path()), - // None => { - // Err(EvalError::EnumVariantStructFieldNotFound { - // field_name: k.clone(), - // variant_name: name.clone(), - // span: span.clone(), - // }) - // } - // }?; - - // let span = v.span.clone(); - - // Ok(( - // k, - // ( - // eval_expression( - // v, - // EvalParams { - // world, - // environment, - // registrations, - // }, - // )?, - // span, - // ty, - // ), - // )) - // }) - // .collect::>()?; - - // let new_enum = - // DynamicEnum::new(name, object_to_dynamic_struct(map)?); - - // let mut dyn_reflect = - // resource.mut_dyn_reflect(world, registrations); - - // let dyn_enum = dyn_reflect - // .reflect_path_mut(resource.path.as_str()) - // .unwrap(); - - // dyn_enum.apply(&new_enum); - // } - // Expression::StructTuple { name, tuple } => { - // let variant_info = match enum_info.variant(&name) { - // Some(variant_info) => variant_info, - // None => { - // return Err(EvalError::EnumVariantNotFound(span.wrap(name))) - // } - // }; - // let VariantInfo::Tuple(variant_info) = variant_info else { - // return todo_error!("{variant_info:?}"); - // }; - - // let tuple = eval_tuple( - // tuple, - // EvalParams { - // world, - // environment, - // registrations, - // }, - // )?; - - // let mut dynamic_tuple = DynamicTuple::default(); - - // for (index, element) in tuple.into_vec().into_iter().enumerate() { - // let ty = match variant_info.field_at(index) { - // Some(field) => Ok(field.type_path_table().short_path()), - // None => Err(EvalError::EnumVariantTupleFieldNotFound { - // field_index: index, - // variant_name: name.clone(), - // span: span.clone(), - // }), - // }?; - - // dynamic_tuple.insert_boxed( - // element.value.into_inner().reflect(element.span, ty)?.into_partial_reflect(), - // ); - // } - - // let new_enum = DynamicEnum::new(name, dynamic_tuple); - - // let mut dyn_reflect = - // resource.mut_dyn_reflect(world, registrations); - - // let dyn_enum = dyn_reflect - // .reflect_path_mut(resource.path.as_str()) - // .unwrap(); - - // dyn_enum.apply(&new_enum); - // } - // _ => todo_error!(), - // } - // } - // _ => { - // let span = value_expr.span.clone(); - // let ty = reflect.reflect_short_type_path().to_owned(); - // let value = eval_expression( - // *value_expr, - // EvalParams { - // world, - // environment, - // registrations, - // }, - // )?; - // let value_reflect = value.reflect(span.clone(), &ty)?; - - // let mut dyn_reflect = resource.mut_dyn_reflect(world, registrations); - - // let reflect = dyn_reflect - // .reflect_path_mut(resource.path.as_str()) - // .unwrap(); - - // reflect.set(value_reflect).map_err(|value_reflect| { - // EvalError::IncompatibleReflectTypes { - // span, - // expected: reflect.reflect_type_path().to_string(), - // actual: value_reflect.reflect_type_path().to_string(), - // } - // })?; - // } - // } + match reflect.reflect_mut() { + ReflectMut::Enum(dyn_enum) => { + let TypeInfo::Enum(enum_info) = registration.type_info() else { + unreachable!() + }; + let Spanned { span, value } = *value_expr; + match value { + Expression::Variable(name) => { + let variant_info = match enum_info.variant(&name) { + Some(variant_info) => variant_info, + None => { + return Err(EvalError::EnumVariantNotFound(span.wrap(name))) + } + }; + let VariantInfo::Unit(_) = variant_info else { + return todo_error!("{variant_info:?}"); + }; + + let new_enum = DynamicEnum::new(name, ()); + + dyn_enum.apply(&new_enum); + } + Expression::StructObject { name, map } => { + let variant_info = match enum_info.variant(&name) { + Some(variant_info) => variant_info, + None => { + return Err(EvalError::EnumVariantNotFound(span.wrap(name))) + } + }; + let VariantInfo::Struct(variant_info) = variant_info else { + return todo_error!("{variant_info:?}"); + }; + + let map: HashMap<_, _> = map + .into_iter() + .map(|(k, v)| { + let ty = match variant_info.field(&k) { + Some(field) => Ok(field.type_path_table().short_path()), + None => { + Err(EvalError::EnumVariantStructFieldNotFound { + field_name: k.clone(), + variant_name: name.clone(), + span: span.clone(), + }) + } + }?; + + let span = v.span.clone(); + + Ok(( + k, + ( + eval_expression( + v, + EvalParams { + world, + environment, + registrations, + }, + )?, + span, + ty, + ), + )) + }) + .collect::>()?; + + let new_enum = + DynamicEnum::new(name, object_to_dynamic_struct(map)?); + + let mut dyn_reflect = + resource.mut_dyn_reflect(world, registrations); + + let dyn_enum = dyn_reflect + .reflect_path_mut(resource.path.as_str()) + .unwrap(); + + dyn_enum.apply(&new_enum); + } + Expression::StructTuple { name, tuple } => { + let variant_info = match enum_info.variant(&name) { + Some(variant_info) => variant_info, + None => { + return Err(EvalError::EnumVariantNotFound(span.wrap(name))) + } + }; + let VariantInfo::Tuple(variant_info) = variant_info else { + return todo_error!("{variant_info:?}"); + }; + + let tuple = eval_tuple( + tuple, + EvalParams { + world, + environment, + registrations, + }, + )?; + + let mut dynamic_tuple = DynamicTuple::default(); + + for (index, element) in tuple.into_vec().into_iter().enumerate() { + let ty = match variant_info.field_at(index) { + Some(field) => Ok(field.type_path_table().short_path()), + None => Err(EvalError::EnumVariantTupleFieldNotFound { + field_index: index, + variant_name: name.clone(), + span: span.clone(), + }), + }?; + + dynamic_tuple.insert_boxed( + element.value.into_inner().reflect(element.span, ty)?.into_partial_reflect(), + ); + } + + let new_enum = DynamicEnum::new(name, dynamic_tuple); + + let mut dyn_reflect = + resource.mut_dyn_reflect(world, registrations); + + let dyn_enum = dyn_reflect + .reflect_path_mut(resource.path.as_str()) + .unwrap(); + + dyn_enum.apply(&new_enum); + } + _ => todo_error!(), + } + } + _ => { + let span = value_expr.span.clone(); + let ty = reflect.reflect_short_type_path().to_owned(); + let value = eval_expression( + *value_expr, + EvalParams { + world, + environment, + registrations, + }, + )?; + let value_reflect = value.reflect(span.clone(), &ty)?; + + let mut dyn_reflect = resource.mut_dyn_reflect(world, registrations); + + let reflect = dyn_reflect + .reflect_path_mut(resource.path.as_str()) + .unwrap(); + + reflect.try_apply(value_reflect.as_partial_reflect()).map_err(|apply_error| { + EvalError::ApplyError {apply_error, span} + })?; + } + } Ok(Value::Resource(resource)) } @@ -441,7 +437,6 @@ fn eval_expression( )?; Ok(Value::StructTuple { name, tuple }) } - Expression::BinaryOp { left, operator, diff --git a/src/builtin_parser/runner/environment.rs b/src/builtin_parser/runner/environment.rs index b30d345..4463134 100644 --- a/src/builtin_parser/runner/environment.rs +++ b/src/builtin_parser/runner/environment.rs @@ -246,11 +246,11 @@ impl Environment { let var = env.variables.get_mut(name); let fn_obj = match var { Some(Variable::Function(_)) => { - let Variable::Function(mut fn_obj) = - std::mem::replace(var.unwrap(), Variable::Moved) - else { - unreachable!() - }; + let Variable::Function(mut fn_obj) = + std::mem::replace(var.unwrap(), Variable::Moved) + else { + unreachable!() + }; return_result = function(env, &mut fn_obj); diff --git a/src/builtin_parser/runner/error.rs b/src/builtin_parser/runner/error.rs index 6892de4..99785d5 100644 --- a/src/builtin_parser/runner/error.rs +++ b/src/builtin_parser/runner/error.rs @@ -1,5 +1,6 @@ use std::borrow::Cow; +use bevy::reflect::ApplyError; use logos::Span; use crate::builtin_parser::number::Number; @@ -75,6 +76,10 @@ pub enum EvalError { field_index: usize, tuple_size: usize, }, + ApplyError { + apply_error: ApplyError, + span: Span + } } impl EvalError { @@ -106,6 +111,7 @@ impl EvalError { E::InvalidOperation { span, .. } => vec![span.clone()], E::IncorrectAccessOperation { span, .. } => vec![span.clone()], E::FieldNotFoundInTuple { span, .. } => vec![span.clone()], + E::ApplyError { span , ..} => vec![span.clone()], } } /// Returns all the hints for this error. @@ -232,6 +238,9 @@ impl std::fmt::Display for EvalError { f, "Field {field_index} is out of bounds for tuple of size {tuple_size}" ), + E::ApplyError { apply_error, span: _} => { + write!(f, "Error while applying value (todo make this error better): {apply_error}") + } } } } diff --git a/src/builtin_parser/runner/value.rs b/src/builtin_parser/runner/value.rs index 791976b..d86e2d8 100644 --- a/src/builtin_parser/runner/value.rs +++ b/src/builtin_parser/runner/value.rs @@ -12,8 +12,7 @@ use super::unique_rc::WeakRef; use bevy::ecs::world::World; use bevy::reflect::{ - DynamicStruct, DynamicTuple, GetPath, Reflect, ReflectRef, TypeInfo, TypeRegistration, - VariantInfo, VariantType, + DynamicStruct, DynamicTuple, GetPath, PartialReflect, Reflect, ReflectRef, TypeInfo, TypeRegistration, VariantInfo, VariantType }; use logos::Span; @@ -61,37 +60,36 @@ pub enum Value { } impl Value { - /// Converts this value into a [`Box`]. + /// Converts this value into a [`Box`]. /// /// `ty` is used for type inference. - pub fn reflect(self, span: Span, ty: &str) -> Result, EvalError> { - todo!() - // match self { - // Value::None => Ok(Box::new(())), - // Value::Number(number) => number.reflect(span, ty), - // Value::Boolean(boolean) => Ok(Box::new(boolean)), - // Value::String(string) => Ok(Box::new(string)), - // Value::Reference(_reference) => Err(EvalError::CannotReflectReference(span)), - // Value::Object(object) | Value::StructObject { map: object, .. } => { - // let mut dyn_struct = DynamicStruct::default(); - - // for (name, value) in object { - // dyn_struct.insert_boxed(&name, value.into_inner().reflect(span.clone(), ty)?); - // } - - // Ok(Box::new(dyn_struct)) - // } - // Value::Tuple(tuple) | Value::StructTuple { tuple, .. } => { - // let mut dyn_tuple = DynamicTuple::default(); - - // for element in Vec::from(tuple).into_iter() { - // dyn_tuple.insert_boxed(element.value.into_inner().reflect(element.span, ty)?); - // } - - // Ok(Box::new(dyn_tuple)) - // } - // Value::Resource(_) => Err(EvalError::CannotReflectResource(span)), - // } + pub fn reflect(self, span: Span, ty: &str) -> Result, EvalError> { + match self { + Value::None => Ok(Box::new(())), + Value::Number(number) => number.reflect(span, ty).map(PartialReflect::into_partial_reflect), + Value::Boolean(boolean) => Ok(Box::new(boolean)), + Value::String(string) => Ok(Box::new(string)), + Value::Reference(_reference) => Err(EvalError::CannotReflectReference(span)), + Value::Object(object) | Value::StructObject { map: object, .. } => { + let mut dyn_struct = DynamicStruct::default(); + + for (name, value) in object { + dyn_struct.insert_boxed(&name, value.into_inner().reflect(span.clone(), ty)?); + } + + Ok(Box::new(dyn_struct)) + } + Value::Tuple(tuple) | Value::StructTuple { tuple, .. } => { + let mut dyn_tuple = DynamicTuple::default(); + + for element in Vec::from(tuple).into_iter() { + dyn_tuple.insert_boxed(element.value.into_inner().reflect(element.span, ty)?); + } + + Ok(Box::new(dyn_tuple)) + } + Value::Resource(_) => Err(EvalError::CannotReflectResource(span)), + } } /// Attempts to format this [`Value`]. @@ -241,173 +239,174 @@ fn fancy_debug_print( registrations: &[&TypeRegistration], ) -> String { const TAB: &str = " "; - todo!() - // let registration = registrations.create_registration(resource.id); - // let dyn_reflect = resource.ref_dyn_reflect(world, registration); - - // let reflect = dyn_reflect.reflect_path(resource.path.as_str()).unwrap(); - - // fn debug_subprint(reflect: &dyn Reflect, indentation: usize) -> String { - // let mut f = String::new(); - // let reflect_ref = reflect.reflect_ref(); - // let indentation_string = TAB.repeat(indentation); - // match reflect_ref { - // ReflectRef::Struct(struct_info) => { - // f += "{\n"; - // for i in 0..struct_info.field_len() { - // let field = struct_info.field_at(i).unwrap(); - // let field_name = struct_info.name_at(i).unwrap(); - - // let field_value = debug_subprint(field, indentation + 1); - // f += &format!( - // "{indentation_string}{TAB}{field_name}: {} = {field_value},\n", - // field.reflect_short_type_path(), - // ); - // } - // f += &indentation_string; - // f += "}"; - // } - // ReflectRef::TupleStruct(_) => todo!(), - // ReflectRef::Tuple(tuple_info) => { - // f += "(\n"; - // for field in tuple_info.iter_fields() { - // let field_value = debug_subprint(field, indentation + 1); - // f += &format!("{indentation_string}{TAB}{field_value},\n",); - // } - // f += &indentation_string; - // f += ")"; - // } - // ReflectRef::List(_) => todo!(), - // ReflectRef::Array(_) => todo!(), - // ReflectRef::Map(_) => todo!(), - // ReflectRef::Enum(variant) => { - // // Print out the enum types - // f += variant.variant_name(); - - // match variant.variant_type() { - // VariantType::Struct => { - // f += " {\n"; - // for field in variant.iter_fields() { - // f += &format!( - // "{indentation_string}{TAB}{}: {} = {},\n", - // field.name().unwrap(), - // field.value().reflect_short_type_path(), - // debug_subprint(field.value(), indentation + 1) - // ); - // } - // f += &indentation_string; - // f += "}"; - // } - // VariantType::Tuple => { - // f += "(\n"; - // for field in variant.iter_fields() { - // f += &format!( - // "{indentation_string}{TAB}{} = {},\n", - // field.value().reflect_short_type_path(), - // debug_subprint(field.value(), indentation + 1) - // ); - // } - // f += &indentation_string; - // f += ")"; - // } - // VariantType::Unit => {} - // } - // } - // ReflectRef::Value(_) => { - // f += &format!("{reflect:?}"); - // } - // } - - // f - // } - - // let mut f = String::new(); - // let reflect_ref = reflect.reflect_ref(); - // match reflect_ref { - // ReflectRef::Struct(struct_info) => { - // f += &format!("struct {} {{\n", struct_info.reflect_short_type_path()); - // for i in 0..struct_info.field_len() { - // let field = struct_info.field_at(i).unwrap(); - // let field_name = struct_info.name_at(i).unwrap(); - - // let field_value = debug_subprint(field, 1); - // f += &format!( - // "{TAB}{}: {} = {},\n", - // field_name, - // field.reflect_short_type_path(), - // field_value - // ); - // } - // f += "}"; - // } - // ReflectRef::TupleStruct(_) => todo!(), - // ReflectRef::Tuple(_) => todo!(), - // ReflectRef::List(_) => todo!(), - // ReflectRef::Array(_) => todo!(), - // ReflectRef::Map(_) => todo!(), - // ReflectRef::Enum(set_variant_info) => { - // // Print out the enum types - // f += &format!("enum {} {{\n", set_variant_info.reflect_short_type_path()); - // let TypeInfo::Enum(enum_info) = registration.type_info() else { - // unreachable!() - // }; - // for variant in enum_info.iter() { - // f += "\t"; - // f += variant.name(); - // match variant { - // VariantInfo::Struct(variant) => { - // f += " {\n"; - // for field in variant.iter() { - // f += &format!( - // "{TAB}{TAB}{}: {},\n", - // field.name(), - // field.type_path_table().short_path() - // ); - // } - // f += TAB; - // f += "}"; - // } - // VariantInfo::Tuple(variant) => { - // f += "("; - // let mut iter = variant.iter(); - // if let Some(first) = iter.next() { - // f += &format!("{}", first.type_path_table().short_path()); - // for field in iter { - // f += &format!(", {}", field.type_path_table().short_path()); - // } - // } - // f += ")"; - // } - // VariantInfo::Unit(_) => {} - // } - // f += ",\n"; - // } - // // Print out the current value - // f += "} = "; - // f += set_variant_info.variant_name(); - // match set_variant_info.variant_type() { - // VariantType::Struct => { - // f += " {\n"; - // for field in set_variant_info.iter_fields() { - // f += &format!("{TAB}{}: {:?},\n", field.name().unwrap(), field.value()); - // } - // f += "}"; - // } - // VariantType::Tuple => { - // f += "(\n"; - // for field in set_variant_info.iter_fields() { - // f += &format!("{TAB}{:?},\n", field.value()); - // } - // f += ")"; - // } - // VariantType::Unit => {} - // } - // } - // ReflectRef::Value(value) => { - // f += &format!("{value:?}"); - // } - // } - // f + let registration = registrations.create_registration(resource.id); + let dyn_reflect = resource.ref_dyn_reflect(world, registration); + + let reflect = dyn_reflect.reflect_path(resource.path.as_str()).unwrap(); + + fn debug_subprint(reflect: &dyn PartialReflect, indentation: usize) -> String { + let mut f = String::new(); + let reflect_ref = reflect.reflect_ref(); + let indentation_string = TAB.repeat(indentation); + match reflect_ref { + ReflectRef::Struct(struct_info) => { + f += "{\n"; + for i in 0..struct_info.field_len() { + let field = struct_info.field_at(i).unwrap(); + let field_name = struct_info.name_at(i).unwrap(); + + let field_value = debug_subprint(field, indentation + 1); + f += &format!( + "{indentation_string}{TAB}{field_name}: {} = {field_value},\n", + field.reflect_short_type_path(), + ); + } + f += &indentation_string; + f += "}"; + } + ReflectRef::TupleStruct(_) => todo!(), + ReflectRef::Tuple(tuple_info) => { + f += "(\n"; + for field in tuple_info.iter_fields() { + let field_value = debug_subprint(field, indentation + 1); + f += &format!("{indentation_string}{TAB}{field_value},\n",); + } + f += &indentation_string; + f += ")"; + } + ReflectRef::List(_) => todo!(), + ReflectRef::Array(_) => todo!(), + ReflectRef::Map(_) => todo!(), + ReflectRef::Enum(variant) => { + // Print out the enum types + f += variant.variant_name(); + + match variant.variant_type() { + VariantType::Struct => { + f += " {\n"; + for field in variant.iter_fields() { + f += &format!( + "{indentation_string}{TAB}{}: {} = {},\n", + field.name().unwrap(), + field.value().reflect_short_type_path(), + debug_subprint(field.value(), indentation + 1) + ); + } + f += &indentation_string; + f += "}"; + } + VariantType::Tuple => { + f += "(\n"; + for field in variant.iter_fields() { + f += &format!( + "{indentation_string}{TAB}{} = {},\n", + field.value().reflect_short_type_path(), + debug_subprint(field.value(), indentation + 1) + ); + } + f += &indentation_string; + f += ")"; + } + VariantType::Unit => {} + } + } + ReflectRef::Opaque(_) => { + f += &format!("{reflect:?}"); + } + ReflectRef::Set(_) => todo!() + } + + f + } + + let mut f = String::new(); + let reflect_ref = reflect.reflect_ref(); + match reflect_ref { + ReflectRef::Struct(struct_info) => { + f += &format!("struct {} {{\n", struct_info.reflect_short_type_path()); + for i in 0..struct_info.field_len() { + let field = struct_info.field_at(i).unwrap(); + let field_name = struct_info.name_at(i).unwrap(); + + let field_value = debug_subprint(field, 1); + f += &format!( + "{TAB}{}: {} = {},\n", + field_name, + field.reflect_short_type_path(), + field_value + ); + } + f += "}"; + } + ReflectRef::TupleStruct(_) => todo!(), + ReflectRef::Tuple(_) => todo!(), + ReflectRef::List(_) => todo!(), + ReflectRef::Array(_) => todo!(), + ReflectRef::Map(_) => todo!(), + ReflectRef::Set(_) => todo!(), + ReflectRef::Enum(set_variant_info) => { + // Print out the enum types + f += &format!("enum {} {{\n", set_variant_info.reflect_short_type_path()); + let TypeInfo::Enum(enum_info) = registration.type_info() else { + unreachable!() + }; + for variant in enum_info.iter() { + f += "\t"; + f += variant.name(); + match variant { + VariantInfo::Struct(variant) => { + f += " {\n"; + for field in variant.iter() { + f += &format!( + "{TAB}{TAB}{}: {},\n", + field.name(), + field.type_path_table().short_path() + ); + } + f += TAB; + f += "}"; + } + VariantInfo::Tuple(variant) => { + f += "("; + let mut iter = variant.iter(); + if let Some(first) = iter.next() { + f += &format!("{}", first.type_path_table().short_path()); + for field in iter { + f += &format!(", {}", field.type_path_table().short_path()); + } + } + f += ")"; + } + VariantInfo::Unit(_) => {} + } + f += ",\n"; + } + // Print out the current value + f += "} = "; + f += set_variant_info.variant_name(); + match set_variant_info.variant_type() { + VariantType::Struct => { + f += " {\n"; + for field in set_variant_info.iter_fields() { + f += &format!("{TAB}{}: {:?},\n", field.name().unwrap(), field.value()); + } + f += "}"; + } + VariantType::Tuple => { + f += "(\n"; + for field in set_variant_info.iter_fields() { + f += &format!("{TAB}{:?},\n", field.value()); + } + f += ")"; + } + VariantType::Unit => {} + } + } + ReflectRef::Opaque(value) => { + f += &format!("{value:?}"); + } + } + f } impl From<()> for Value { From 960158bc1e45ead0291a78711760a4f3aa366168 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rezan=20Kizilg=C3=BCn?= Date: Fri, 4 Jul 2025 21:34:30 +0200 Subject: [PATCH 3/5] Updated to bevy 0.16 --- .idea/.gitignore | 5 +++++ .idea/encodings.xml | 4 ++++ Cargo.toml | 6 +++--- src/builtin_parser/runner.rs | 4 +--- src/builtin_parser/runner/environment.rs | 2 +- src/builtin_parser/runner/reflection.rs | 2 +- src/builtin_parser/runner/stdlib.rs | 2 +- src/builtin_parser/runner/unique_rc.rs | 2 +- src/builtin_parser/runner/value.rs | 2 +- src/command.rs | 2 +- src/lib.rs | 2 +- src/logging.rs | 13 ++++++------- src/ui.rs | 19 ++++++++++--------- 13 files changed, 36 insertions(+), 29 deletions(-) create mode 100644 .idea/.gitignore create mode 100644 .idea/encodings.xml diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..339a774 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,5 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..df87cf9 --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 6fbaa60..5a16542 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,8 +23,8 @@ builtin-parser = ["dep:logos"] [dependencies] # This crate by itself doesn't use any bevy features, but `bevy_egui` (dep) uses "bevy_asset". -bevy = { version = "0.15.0", default-features = false, features = [] } -bevy_egui = "0.31.1" +bevy = { version = "0.16.0", default-features = false, features = ["bevy_log", "bevy_color"] } +bevy_egui = "0.34.1" chrono = "0.4.31" tracing-log = "0.2.0" tracing-subscriber = "0.3.18" @@ -36,7 +36,7 @@ logos = { version = "0.14.0", optional = true } fuzzy-matcher = { version = "0.3.7", optional = true } [dev-dependencies] -bevy = "0.15.0" +bevy = "0.16.0" [lints] clippy.useless_format = "allow" diff --git a/src/builtin_parser/runner.rs b/src/builtin_parser/runner.rs index 500efcf..d4058cc 100644 --- a/src/builtin_parser/runner.rs +++ b/src/builtin_parser/runner.rs @@ -8,8 +8,6 @@ use bevy::reflect::{ DynamicEnum, DynamicTuple, ReflectMut, TypeInfo, TypeRegistration, VariantInfo, }; -use crate::ui::COMMAND_RESULT_NAME; - use self::error::EvalError; use self::member::{eval_member_expression, eval_path, Path}; use self::reflection::{object_to_dynamic_struct, CreateRegistration, IntoResource}; @@ -142,7 +140,7 @@ pub fn run(ast: Ast, world: &mut World) -> Result<(), ExecutionError> { value => { let value = value.try_format(span, world, ®istrations)?; - info!(name: COMMAND_RESULT_NAME, "{}{value}", crate::ui::COMMAND_RESULT_PREFIX); + info!(name: crate::ui::COMMAND_RESULT_NAME, "{}{value}", crate::ui::COMMAND_RESULT_PREFIX); } } } diff --git a/src/builtin_parser/runner/environment.rs b/src/builtin_parser/runner/environment.rs index 4463134..4110465 100644 --- a/src/builtin_parser/runner/environment.rs +++ b/src/builtin_parser/runner/environment.rs @@ -4,8 +4,8 @@ use std::collections::HashMap; use std::fmt::Debug; use crate::builtin_parser::SpanExtension; +use bevy::prelude::*; use bevy::ecs::world::World; -use bevy::log::warn; use bevy::reflect::TypeRegistration; use logos::Span; diff --git a/src/builtin_parser/runner/reflection.rs b/src/builtin_parser/runner/reflection.rs index c107c75..f8bd2e1 100644 --- a/src/builtin_parser/runner/reflection.rs +++ b/src/builtin_parser/runner/reflection.rs @@ -46,7 +46,7 @@ impl IntoResource { } pub fn object_to_dynamic_struct( - hashmap: HashMap, + _hashmap: HashMap, ) -> Result { todo!() // let mut dynamic_struct = DynamicStruct::default(); diff --git a/src/builtin_parser/runner/stdlib.rs b/src/builtin_parser/runner/stdlib.rs index 938df3b..81d5f5c 100644 --- a/src/builtin_parser/runner/stdlib.rs +++ b/src/builtin_parser/runner/stdlib.rs @@ -1,7 +1,7 @@ use crate::builtin_parser::runner::environment::Variable; use crate::register; +use bevy::prelude::*; use bevy::ecs::world::World; -use bevy::log::info; use bevy::reflect::TypeRegistration; use std::cell::Ref; use std::ops::Range; diff --git a/src/builtin_parser/runner/unique_rc.rs b/src/builtin_parser/runner/unique_rc.rs index f4e5c29..1b5f016 100644 --- a/src/builtin_parser/runner/unique_rc.rs +++ b/src/builtin_parser/runner/unique_rc.rs @@ -46,7 +46,7 @@ impl UniqueRc { .into_inner() } } -impl Clone for UniqueRc { +impl Clone for UniqueRc { fn clone(&self) -> Self { let t = self.borrow_inner().clone().into_inner(); diff --git a/src/builtin_parser/runner/value.rs b/src/builtin_parser/runner/value.rs index d86e2d8..23ceda5 100644 --- a/src/builtin_parser/runner/value.rs +++ b/src/builtin_parser/runner/value.rs @@ -12,7 +12,7 @@ use super::unique_rc::WeakRef; use bevy::ecs::world::World; use bevy::reflect::{ - DynamicStruct, DynamicTuple, GetPath, PartialReflect, Reflect, ReflectRef, TypeInfo, TypeRegistration, VariantInfo, VariantType + DynamicStruct, DynamicTuple, GetPath, PartialReflect, ReflectRef, TypeInfo, TypeRegistration, VariantInfo, VariantType }; use logos::Span; diff --git a/src/command.rs b/src/command.rs index 8ab6fa4..a3f0bd5 100644 --- a/src/command.rs +++ b/src/command.rs @@ -3,7 +3,6 @@ use std::borrow::Cow; use std::ops::Range; -use bevy::ecs::world::Command; use bevy::prelude::*; /// The command parser currently being used by the dev console. @@ -168,6 +167,7 @@ impl Command for ExecuteCommand { } } +#[allow(missing_docs)] #[derive(Resource, Default, Deref, DerefMut)] #[cfg(feature = "completions")] pub struct AutoCompletions(pub(crate) Vec); diff --git a/src/lib.rs b/src/lib.rs index 46fb4cb..9cdcf37 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -21,7 +21,7 @@ pub struct DevConsolePlugin; impl Plugin for DevConsolePlugin { fn build(&self, app: &mut App) { if !app.is_plugin_added::() { - app.add_plugins(EguiPlugin); + app.add_plugins(EguiPlugin { enable_multipass_for_primary_context: false }); } #[cfg(feature = "builtin-parser")] diff --git a/src/logging.rs b/src/logging.rs index 1c375ad..6f9848d 100644 --- a/src/logging.rs +++ b/src/logging.rs @@ -1,16 +1,15 @@ //! Custom [LogPlugin](bevy::log::LogPlugin) functionality. -use bevy::log::{BoxedLayer, Level}; use bevy::prelude::*; -use bevy::utils::tracing::Subscriber; use std::sync::mpsc; +use bevy::log::tracing::Subscriber; use tracing_subscriber::field::Visit; use tracing_subscriber::Layer; use web_time::SystemTime; /// A function that implements the log reading functionality for the /// developer console via [`LogPlugin::custom_layer`](bevy::log::LogPlugin::custom_layer). -pub fn custom_log_layer(app: &mut App) -> Option { +pub fn custom_log_layer(app: &mut App) -> Option { Some(Box::new(create_custom_log_layer(app))) } @@ -39,7 +38,7 @@ pub(crate) struct LogMessage { pub target: &'static str, /// The level of verbosity of the described span. - pub level: Level, + pub level: bevy::log::Level, /// The name of the Rust module where the span occurred, /// or `None` if this could not be determined. @@ -62,7 +61,7 @@ fn transfer_log_events( receiver: NonSend, mut log_events: EventWriter, ) { - log_events.send_batch(receiver.0.try_iter()); + log_events.write_batch(receiver.0.try_iter()); } /// This struct temporarily stores [`LogMessage`]s before they are @@ -76,7 +75,7 @@ struct LogCaptureLayer { impl Layer for LogCaptureLayer { fn on_event( &self, - event: &bevy::utils::tracing::Event<'_>, + event: &bevy::log::tracing::Event<'_>, _ctx: tracing_subscriber::layer::Context<'_, S>, ) { let mut message = None; @@ -104,7 +103,7 @@ struct LogEventVisitor<'a>(&'a mut Option); impl Visit for LogEventVisitor<'_> { fn record_debug( &mut self, - field: &bevy::utils::tracing::field::Field, + field: &bevy::log::tracing::field::Field, value: &dyn std::fmt::Debug, ) { // Only log out messages diff --git a/src/ui.rs b/src/ui.rs index fed5d90..a42bf8d 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -31,6 +31,7 @@ pub const COMMAND_MESSAGE_NAME: &str = "console_command"; /// Identifier for log messages that show the result of a command. pub const COMMAND_RESULT_NAME: &str = "console_result"; +#[allow(missing_docs)] #[derive(Default, Resource)] pub struct ConsoleUiState { /// Whether the console is open or not. @@ -125,18 +126,18 @@ pub fn render_ui( submit_command(&mut state.command, commands); } - completions::change_selected_completion(ui, state, &completions); + completions::change_selected_completion(ui, state, completions); // A General rule when creating layouts in egui is to place elements which fill remaining space last. // Since immediate mode ui can't predict the final sizes of widgets until they've already been drawn // Thus we create a bottom panel first, where our text edit and submit button resides. egui::TopBottomPanel::bottom("bottom panel") - .frame(egui::Frame::none().outer_margin(egui::Margin { - left: 5.0, - right: 5.0, - top: 5. + 6., - bottom: 5.0, + .frame(egui::Frame::NONE.outer_margin(egui::Margin { + left: 5, + right: 5, + top: 5 + 6, + bottom: 5, })) .show_inside(ui, |ui| { let text_edit_id = egui::Id::new("text_edit"); @@ -169,8 +170,8 @@ pub fn render_ui( state, ui, commands, - &completions, - &config, + completions, + config, ); // Each time we open the console, we want to set focus to the text edit control. @@ -188,7 +189,7 @@ pub fn render_ui( let mut command_index = 0; for (id, (message, is_new)) in state.log.iter_mut().enumerate() { - add_log(ui, id, message, is_new, hints, &config, &mut command_index); + add_log(ui, id, message, is_new, hints, config, &mut command_index); } }); }); From 6ffb5271de69b7c5db667ada3b5e10359cbe5105 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rezan=20Kizilg=C3=BCn?= Date: Fri, 4 Jul 2025 21:37:39 +0200 Subject: [PATCH 4/5] Ran cargo fmt --- src/builtin_parser/runner.rs | 12 ++++++++---- src/builtin_parser/runner/environment.rs | 12 ++++++------ src/builtin_parser/runner/error.rs | 16 +++++++++++----- src/builtin_parser/runner/stdlib.rs | 2 +- src/builtin_parser/runner/value.rs | 9 ++++++--- src/lib.rs | 4 +++- src/logging.rs | 2 +- 7 files changed, 36 insertions(+), 21 deletions(-) diff --git a/src/builtin_parser/runner.rs b/src/builtin_parser/runner.rs index d4058cc..f53fcfc 100644 --- a/src/builtin_parser/runner.rs +++ b/src/builtin_parser/runner.rs @@ -330,7 +330,11 @@ fn eval_expression( }?; dynamic_tuple.insert_boxed( - element.value.into_inner().reflect(element.span, ty)?.into_partial_reflect(), + element + .value + .into_inner() + .reflect(element.span, ty)? + .into_partial_reflect(), ); } @@ -367,9 +371,9 @@ fn eval_expression( .reflect_path_mut(resource.path.as_str()) .unwrap(); - reflect.try_apply(value_reflect.as_partial_reflect()).map_err(|apply_error| { - EvalError::ApplyError {apply_error, span} - })?; + reflect + .try_apply(value_reflect.as_partial_reflect()) + .map_err(|apply_error| EvalError::ApplyError { apply_error, span })?; } } diff --git a/src/builtin_parser/runner/environment.rs b/src/builtin_parser/runner/environment.rs index 4110465..32bf463 100644 --- a/src/builtin_parser/runner/environment.rs +++ b/src/builtin_parser/runner/environment.rs @@ -4,8 +4,8 @@ use std::collections::HashMap; use std::fmt::Debug; use crate::builtin_parser::SpanExtension; -use bevy::prelude::*; use bevy::ecs::world::World; +use bevy::prelude::*; use bevy::reflect::TypeRegistration; use logos::Span; @@ -246,11 +246,11 @@ impl Environment { let var = env.variables.get_mut(name); let fn_obj = match var { Some(Variable::Function(_)) => { - let Variable::Function(mut fn_obj) = - std::mem::replace(var.unwrap(), Variable::Moved) - else { - unreachable!() - }; + let Variable::Function(mut fn_obj) = + std::mem::replace(var.unwrap(), Variable::Moved) + else { + unreachable!() + }; return_result = function(env, &mut fn_obj); diff --git a/src/builtin_parser/runner/error.rs b/src/builtin_parser/runner/error.rs index 99785d5..b3cafc3 100644 --- a/src/builtin_parser/runner/error.rs +++ b/src/builtin_parser/runner/error.rs @@ -78,8 +78,8 @@ pub enum EvalError { }, ApplyError { apply_error: ApplyError, - span: Span - } + span: Span, + }, } impl EvalError { @@ -111,7 +111,7 @@ impl EvalError { E::InvalidOperation { span, .. } => vec![span.clone()], E::IncorrectAccessOperation { span, .. } => vec![span.clone()], E::FieldNotFoundInTuple { span, .. } => vec![span.clone()], - E::ApplyError { span , ..} => vec![span.clone()], + E::ApplyError { span, .. } => vec![span.clone()], } } /// Returns all the hints for this error. @@ -238,8 +238,14 @@ impl std::fmt::Display for EvalError { f, "Field {field_index} is out of bounds for tuple of size {tuple_size}" ), - E::ApplyError { apply_error, span: _} => { - write!(f, "Error while applying value (todo make this error better): {apply_error}") + E::ApplyError { + apply_error, + span: _, + } => { + write!( + f, + "Error while applying value (todo make this error better): {apply_error}" + ) } } } diff --git a/src/builtin_parser/runner/stdlib.rs b/src/builtin_parser/runner/stdlib.rs index 81d5f5c..0561f25 100644 --- a/src/builtin_parser/runner/stdlib.rs +++ b/src/builtin_parser/runner/stdlib.rs @@ -1,7 +1,7 @@ use crate::builtin_parser::runner::environment::Variable; use crate::register; -use bevy::prelude::*; use bevy::ecs::world::World; +use bevy::prelude::*; use bevy::reflect::TypeRegistration; use std::cell::Ref; use std::ops::Range; diff --git a/src/builtin_parser/runner/value.rs b/src/builtin_parser/runner/value.rs index 23ceda5..ac1487c 100644 --- a/src/builtin_parser/runner/value.rs +++ b/src/builtin_parser/runner/value.rs @@ -12,7 +12,8 @@ use super::unique_rc::WeakRef; use bevy::ecs::world::World; use bevy::reflect::{ - DynamicStruct, DynamicTuple, GetPath, PartialReflect, ReflectRef, TypeInfo, TypeRegistration, VariantInfo, VariantType + DynamicStruct, DynamicTuple, GetPath, PartialReflect, ReflectRef, TypeInfo, TypeRegistration, + VariantInfo, VariantType, }; use logos::Span; @@ -66,7 +67,9 @@ impl Value { pub fn reflect(self, span: Span, ty: &str) -> Result, EvalError> { match self { Value::None => Ok(Box::new(())), - Value::Number(number) => number.reflect(span, ty).map(PartialReflect::into_partial_reflect), + Value::Number(number) => number + .reflect(span, ty) + .map(PartialReflect::into_partial_reflect), Value::Boolean(boolean) => Ok(Box::new(boolean)), Value::String(string) => Ok(Box::new(string)), Value::Reference(_reference) => Err(EvalError::CannotReflectReference(span)), @@ -313,7 +316,7 @@ fn fancy_debug_print( ReflectRef::Opaque(_) => { f += &format!("{reflect:?}"); } - ReflectRef::Set(_) => todo!() + ReflectRef::Set(_) => todo!(), } f diff --git a/src/lib.rs b/src/lib.rs index 9cdcf37..78f1c23 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -21,7 +21,9 @@ pub struct DevConsolePlugin; impl Plugin for DevConsolePlugin { fn build(&self, app: &mut App) { if !app.is_plugin_added::() { - app.add_plugins(EguiPlugin { enable_multipass_for_primary_context: false }); + app.add_plugins(EguiPlugin { + enable_multipass_for_primary_context: false, + }); } #[cfg(feature = "builtin-parser")] diff --git a/src/logging.rs b/src/logging.rs index 6f9848d..af638ad 100644 --- a/src/logging.rs +++ b/src/logging.rs @@ -1,8 +1,8 @@ //! Custom [LogPlugin](bevy::log::LogPlugin) functionality. +use bevy::log::tracing::Subscriber; use bevy::prelude::*; use std::sync::mpsc; -use bevy::log::tracing::Subscriber; use tracing_subscriber::field::Visit; use tracing_subscriber::Layer; use web_time::SystemTime; From bde3c3d6b2639353a86b85af2f4843e1a9330501 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rezan=20Kizilg=C3=BCn?= Date: Sun, 13 Jul 2025 23:17:13 +0200 Subject: [PATCH 5/5] Added 'bevy_reflect' dependency for external packages --- Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/Cargo.toml b/Cargo.toml index 5a16542..c83d27d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,6 +24,7 @@ builtin-parser = ["dep:logos"] [dependencies] # This crate by itself doesn't use any bevy features, but `bevy_egui` (dep) uses "bevy_asset". bevy = { version = "0.16.0", default-features = false, features = ["bevy_log", "bevy_color"] } +bevy_reflect = "0.16.0" bevy_egui = "0.34.1" chrono = "0.4.31" tracing-log = "0.2.0"