kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity
160f72b4cd
rhai/src/reify.rs

49 lines
1.8 KiB
Rust
Raw Normal View History

Doc fixes.
2022-02-10 01:31:41 +01:00
/// Macro to cast an identifier or expression to another type with type checks.
Fix errors.
2022-02-06 16:02:59 +01:00
///
Doc fixes.
2022-02-10 01:31:41 +01:00
/// Runs _code_ if _variable_ or _expression_ is of type _type_, otherwise run _fallback_.
///
/// # Syntax
///
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
/// * `reify! { `_variable_ or _expression_` => |`_temp-variable_`: `_type_`|` _code_`,` `||` _fallback_ `)`
/// * `reify! { `_variable_ or _expression_` => |`_temp-variable_`: `_type_`|` _code_ `)`
/// * `reify! { `_variable_ or _expression_ `=>` `Option<`_type_`>` `)`
/// * `reify! { `_variable_ or _expression_ `=>` _type_ `)`
Remove unsound casting functions The casting functions in `unsafe.rs` were unsound (i.e., they allowed safe code to cause undefined behavior). While they did appear to be used in a way that wouldn't cause UB the fact that there exists unsound functions is unsettling. This commit removes those functions and replaces it with a macro that performs the same reification - the difference is that the macro call will also include the checks which are required to prevent UB. A macro was chosen instead of a function for two reasons: 1. A macro can keep the same code generation whereas a function would require going through an `Option` which has negative impacts on code generation (niche values cause poor DCE). 2. There exist other `unsafe` code blocks in the crate and an attempt to make Rhai 100% safe is completely out-of-scope for this merge request, so we may as well use `unsafe` in the macro. Regarding (2) above, I may come back at a later date with a 100% safe `reify` function but only once the other `unsafe` blocks are removed. For posterity, said function would look something like: ```rust fn reify<A: Any, C>(value: A) -> Option<C> { let mut v = Some(value); let v: &mut dyn Any = &mut v; v.downcast_mut::<Option<C>>().map(Option::take) } ```
2022-02-06 01:29:05 +01:00
macro_rules! reify {
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
($old:ident => |$new:ident : $t:ty| $code:expr, || $fallback:expr) => {{
Shut up clippy.
2022-08-27 10:26:41 +02:00
#[allow(clippy::redundant_else)]
Remove reify_dynamic.
2022-02-07 05:02:00 +01:00
if std::any::TypeId::of::<$t>() == std::any::Any::type_id(&$old) {
Doc fixes.
2022-02-10 01:31:41 +01:00
// SAFETY: This is safe because we already checked to make sure the two types
// are actually the same.
Fix errors.
2022-02-06 16:02:59 +01:00
let $new: $t = unsafe { std::mem::transmute_copy(&std::mem::ManuallyDrop::new($old)) };
Remove unsound casting functions The casting functions in `unsafe.rs` were unsound (i.e., they allowed safe code to cause undefined behavior). While they did appear to be used in a way that wouldn't cause UB the fact that there exists unsound functions is unsettling. This commit removes those functions and replaces it with a macro that performs the same reification - the difference is that the macro call will also include the checks which are required to prevent UB. A macro was chosen instead of a function for two reasons: 1. A macro can keep the same code generation whereas a function would require going through an `Option` which has negative impacts on code generation (niche values cause poor DCE). 2. There exist other `unsafe` code blocks in the crate and an attempt to make Rhai 100% safe is completely out-of-scope for this merge request, so we may as well use `unsafe` in the macro. Regarding (2) above, I may come back at a later date with a 100% safe `reify` function but only once the other `unsafe` blocks are removed. For posterity, said function would look something like: ```rust fn reify<A: Any, C>(value: A) -> Option<C> { let mut v = Some(value); let v: &mut dyn Any = &mut v; v.downcast_mut::<Option<C>>().map(Option::take) } ```
2022-02-06 01:29:05 +01:00
$code
} else {
$fallback
}
}};
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
($old:expr => |$new:ident : $t:ty| $code:expr, || $fallback:expr) => {{
Remove unsound casting functions The casting functions in `unsafe.rs` were unsound (i.e., they allowed safe code to cause undefined behavior). While they did appear to be used in a way that wouldn't cause UB the fact that there exists unsound functions is unsettling. This commit removes those functions and replaces it with a macro that performs the same reification - the difference is that the macro call will also include the checks which are required to prevent UB. A macro was chosen instead of a function for two reasons: 1. A macro can keep the same code generation whereas a function would require going through an `Option` which has negative impacts on code generation (niche values cause poor DCE). 2. There exist other `unsafe` code blocks in the crate and an attempt to make Rhai 100% safe is completely out-of-scope for this merge request, so we may as well use `unsafe` in the macro. Regarding (2) above, I may come back at a later date with a 100% safe `reify` function but only once the other `unsafe` blocks are removed. For posterity, said function would look something like: ```rust fn reify<A: Any, C>(value: A) -> Option<C> { let mut v = Some(value); let v: &mut dyn Any = &mut v; v.downcast_mut::<Option<C>>().map(Option::take) } ```
2022-02-06 01:29:05 +01:00
let old = $old;
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
reify! { old => |$new: $t| $code, || $fallback }
Remove unsound casting functions The casting functions in `unsafe.rs` were unsound (i.e., they allowed safe code to cause undefined behavior). While they did appear to be used in a way that wouldn't cause UB the fact that there exists unsound functions is unsettling. This commit removes those functions and replaces it with a macro that performs the same reification - the difference is that the macro call will also include the checks which are required to prevent UB. A macro was chosen instead of a function for two reasons: 1. A macro can keep the same code generation whereas a function would require going through an `Option` which has negative impacts on code generation (niche values cause poor DCE). 2. There exist other `unsafe` code blocks in the crate and an attempt to make Rhai 100% safe is completely out-of-scope for this merge request, so we may as well use `unsafe` in the macro. Regarding (2) above, I may come back at a later date with a 100% safe `reify` function but only once the other `unsafe` blocks are removed. For posterity, said function would look something like: ```rust fn reify<A: Any, C>(value: A) -> Option<C> { let mut v = Some(value); let v: &mut dyn Any = &mut v; v.downcast_mut::<Option<C>>().map(Option::take) } ```
2022-02-06 01:29:05 +01:00
}};
Doc fixes.
2022-02-10 01:31:41 +01:00
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
($old:ident => |$new:ident : $t:ty| $code:expr) => {
reify! { $old => |$new: $t| $code, || () }
Remove unsound casting functions The casting functions in `unsafe.rs` were unsound (i.e., they allowed safe code to cause undefined behavior). While they did appear to be used in a way that wouldn't cause UB the fact that there exists unsound functions is unsettling. This commit removes those functions and replaces it with a macro that performs the same reification - the difference is that the macro call will also include the checks which are required to prevent UB. A macro was chosen instead of a function for two reasons: 1. A macro can keep the same code generation whereas a function would require going through an `Option` which has negative impacts on code generation (niche values cause poor DCE). 2. There exist other `unsafe` code blocks in the crate and an attempt to make Rhai 100% safe is completely out-of-scope for this merge request, so we may as well use `unsafe` in the macro. Regarding (2) above, I may come back at a later date with a 100% safe `reify` function but only once the other `unsafe` blocks are removed. For posterity, said function would look something like: ```rust fn reify<A: Any, C>(value: A) -> Option<C> { let mut v = Some(value); let v: &mut dyn Any = &mut v; v.downcast_mut::<Option<C>>().map(Option::take) } ```
2022-02-06 01:29:05 +01:00
};
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
($old:expr => |$new:ident : $t:ty| $code:expr) => {
reify! { $old => |$new: $t| $code, || () }
Remove unsound casting functions The casting functions in `unsafe.rs` were unsound (i.e., they allowed safe code to cause undefined behavior). While they did appear to be used in a way that wouldn't cause UB the fact that there exists unsound functions is unsettling. This commit removes those functions and replaces it with a macro that performs the same reification - the difference is that the macro call will also include the checks which are required to prevent UB. A macro was chosen instead of a function for two reasons: 1. A macro can keep the same code generation whereas a function would require going through an `Option` which has negative impacts on code generation (niche values cause poor DCE). 2. There exist other `unsafe` code blocks in the crate and an attempt to make Rhai 100% safe is completely out-of-scope for this merge request, so we may as well use `unsafe` in the macro. Regarding (2) above, I may come back at a later date with a 100% safe `reify` function but only once the other `unsafe` blocks are removed. For posterity, said function would look something like: ```rust fn reify<A: Any, C>(value: A) -> Option<C> { let mut v = Some(value); let v: &mut dyn Any = &mut v; v.downcast_mut::<Option<C>>().map(Option::take) } ```
2022-02-06 01:29:05 +01:00
};
Improve reify syntax.
2022-02-08 02:25:53 +01:00
($old:ident => Option<$t:ty>) => {
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
reify! { $old => |v: $t| Some(v), || None }
Improve reify syntax.
2022-02-08 02:25:53 +01:00
};
($old:expr => Option<$t:ty>) => {
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
reify! { $old => |v: $t| Some(v), || None }
Improve reify syntax.
2022-02-08 02:25:53 +01:00
};
($old:ident => $t:ty) => {
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
reify! { $old => |v: $t| v, || unreachable!() }
Improve reify syntax.
2022-02-08 02:25:53 +01:00
};
($old:expr => $t:ty) => {
Improve reify! syntax.
2022-12-09 09:41:01 +01:00
reify! { $old => |v: $t| v, || unreachable!() }
Improve reify syntax.
2022-02-08 02:25:53 +01:00
};
Remove unsound casting functions The casting functions in `unsafe.rs` were unsound (i.e., they allowed safe code to cause undefined behavior). While they did appear to be used in a way that wouldn't cause UB the fact that there exists unsound functions is unsettling. This commit removes those functions and replaces it with a macro that performs the same reification - the difference is that the macro call will also include the checks which are required to prevent UB. A macro was chosen instead of a function for two reasons: 1. A macro can keep the same code generation whereas a function would require going through an `Option` which has negative impacts on code generation (niche values cause poor DCE). 2. There exist other `unsafe` code blocks in the crate and an attempt to make Rhai 100% safe is completely out-of-scope for this merge request, so we may as well use `unsafe` in the macro. Regarding (2) above, I may come back at a later date with a 100% safe `reify` function but only once the other `unsafe` blocks are removed. For posterity, said function would look something like: ```rust fn reify<A: Any, C>(value: A) -> Option<C> { let mut v = Some(value); let v: &mut dyn Any = &mut v; v.downcast_mut::<Option<C>>().map(Option::take) } ```
2022-02-06 01:29:05 +01:00
}
Reference in New Issue Copy Permalink