Add support for overloading derived field functions

udoprog · udoprog · commit 5915aa8451df · 2020-11-25T04:24:45.000+01:00
diff --git a/book/src/field_functions.md b/book/src/field_functions.md
@@ -46,6 +46,7 @@ are:
 | [`Protocol::BIT_XOR_ASSIGN`] | `#[rune(bit_xor_assign)]` | The `^=` operation. |
 | [`Protocol::SHL_ASSIGN`] | `#[rune(shl_assign)]` | The `<<=` operation. |
 | [`Protocol::SHR_ASSIGN`] | `#[rune(shr_assign)]` | The `>>=` operation. |
+| [`Protocol::REM_ASSIGN`] | `#[rune(rem_assign)]` | The `%=` operation. |
 
 The manual way to register these functions is to use the new `Module::field_fn`
 function. This clearly showcases that there's no relationship between the field
@@ -76,6 +77,23 @@ pub fn main(external) {
 }
 ```
 
+## Custom field function
+
+Using the `Any` derive, you can specify a custom field function by using an
+argument to the corresponding attribute pointing to the function to use instead.
+
+The following uses an implementation of `add_assign` which performs checked
+addition:
+
+```rust,noplaypen
+{{#include ../../crates/rune/examples/checked_add_assign.rs}}
+```
+
+```text
+$> cargo run --example checked_add_assign
+Error: numerical overflow (at inst 2)
+```
+
 [`Protocol::GET`]: https://docs.rs/runestick/0/runestick/struct.Protocol.html#associatedconstant.GET
 [`Protocol::SET`]: https://docs.rs/runestick/0/runestick/struct.Protocol.html#associatedconstant.SET
 [`Protocol::ADD_ASSIGN`]: https://docs.rs/runestick/0/runestick/struct.Protocol.html#associatedconstant.ADD_ASSIGN
@@ -87,3 +105,4 @@ pub fn main(external) {
 [`Protocol::BIT_XOR_ASSIGN`]: https://docs.rs/runestick/0/runestick/struct.Protocol.html#associatedconstant.BIT_XOR_ASSIGN
 [`Protocol::SHL_ASSIGN`]: https://docs.rs/runestick/0/runestick/struct.Protocol.html#associatedconstant.SHL_ASSIGN
 [`Protocol::SHR_ASSIGN`]: https://docs.rs/runestick/0/runestick/struct.Protocol.html#associatedconstant.SHR_ASSIGN
+[`Protocol::REM_ASSIGN`]: https://docs.rs/runestick/0/runestick/struct.Protocol.html#associatedconstant.REM_ASSIGN
diff --git a/crates/rune/examples/checked_add_assign.rs b/crates/rune/examples/checked_add_assign.rs
@@ -0,0 +1,44 @@
+use runestick::{Any, Context, Module, VmError, VmErrorKind};
+use std::sync::Arc;
+
+#[derive(Any)]
+struct External {
+    #[rune(add_assign = "External::value_add_assign")]
+    value: i64,
+}
+
+impl External {
+    fn value_add_assign(&mut self, other: i64) -> Result<(), VmError> {
+        self.value = self
+            .value
+            .checked_add(other)
+            .ok_or_else(|| VmErrorKind::Overflow)?;
+
+        Ok(())
+    }
+}
+
+fn main() -> runestick::Result<()> {
+    let mut module = Module::default();
+    module.ty::<External>()?;
+
+    let mut context = Context::default();
+    context.install(&module)?;
+    let context = Arc::new(context);
+
+    let external = External {
+        value: i64::max_value(),
+    };
+
+    let result = rune::testing::run::<_, _, ()>(
+        &context,
+        &["main"],
+        (external,),
+        "pub fn main(external) { external.value += 1; }",
+    );
+
+    let error = result.expect_err("expected error");
+    let error = error.expect_vm_error("expected vm error");
+    println!("Error: {}", error);
+    Ok(())
+}
diff --git a/crates/rune/src/testing.rs b/crates/rune/src/testing.rs
@@ -29,6 +29,16 @@ pub enum RunError {
     VmError(#[source] VmError),
 }
 
+impl RunError {
+    /// Unpack into a vm error or panic with the given message.
+    pub fn expect_vm_error(self, msg: &str) -> VmError {
+        match self {
+            Self::VmError(error) => error,
+            _ => panic!("{}", msg),
+        }
+    }
+}
+
 /// Compile the given source into a unit and collection of warnings.
 pub fn compile_source(
     context: &runestick::Context,
diff --git a/crates/rune/tests/test_all/external_ops.rs b/crates/rune/tests/test_all/external_ops.rs
@@ -13,6 +13,8 @@ fn test_external_ops() {
                 field: i64,
                 #[rune($derived)]
                 derived: i64,
+                #[rune($derived = "External::custom")]
+                custom: i64,
             }
 
             impl External {
@@ -23,6 +25,10 @@ fn test_external_ops() {
                 fn field(&mut self, value: i64) {
                     self.field $($op)* value;
                 }
+
+                fn custom(&mut self, value: i64) {
+                    self.custom $($op)* value;
+                }
             }
 
             let mut module = Module::empty();
@@ -49,6 +55,7 @@ fn test_external_ops() {
                     number {op} {arg};
                     number.field {op} {arg};
                     number.derived {op} {arg};
+                    number.custom {op} {arg};
                 }}
                 "#, op = stringify!($($op)*), arg = stringify!($arg)),
             ));
@@ -72,12 +79,14 @@ fn test_external_ops() {
                 foo.value = $initial;
                 foo.field = $initial;
                 foo.derived = $initial;
+                foo.custom = $initial;
 
                 let output = vm.clone().call(&["type"], (&mut foo,)).unwrap();
 
-                assert_eq!(foo.value, $expected);
-                assert_eq!(foo.field, $expected);
-                assert_eq!(foo.derived, $expected);
+                assert_eq!(foo.value, $expected, "{} != {} (value)", foo.value, $expected);
+                assert_eq!(foo.field, $expected, "{} != {} (field)", foo.value, $expected);
+                assert_eq!(foo.derived, $expected, "{} != {} (derived)", foo.value, $expected);
+                assert_eq!(foo.custom, $expected, "{} != {} (custom)", foo.value, $expected);
                 assert!(matches!(output, Value::Unit));
             }
         }};
@@ -92,4 +101,5 @@ fn test_external_ops() {
     test_case!([^=], BIT_XOR_ASSIGN, bit_xor_assign, 0b1001, 0b0011, 0b1010);
     test_case!([<<=], SHL_ASSIGN, shl_assign, 0b1001, 0b0001, 0b10010);
     test_case!([>>=], SHR_ASSIGN, shr_assign, 0b1001, 0b0001, 0b100);
+    test_case!([%=], REM_ASSIGN, rem_assign, 25, 10, 5);
 }
diff --git a/crates/runestick-macros/src/context.rs b/crates/runestick-macros/src/context.rs
@@ -11,6 +11,7 @@ use syn::NestedMeta::*;
 struct Generate<'a> {
     context: &'a Context,
     attrs: &'a FieldAttrs,
+    protocol: &'a FieldProtocol,
     ident: &'a syn::Ident,
     field: &'a syn::Field,
     field_ident: &'a syn::Ident,
@@ -20,6 +21,7 @@ struct Generate<'a> {
 
 pub(crate) struct FieldProtocol {
     generate: fn(Generate<'_>) -> TokenStream,
+    custom: Option<syn::Path>,
 }
 
 /// Parsed field attributes.
@@ -148,10 +150,16 @@ impl Context {
 
                     let protocol = g.context.protocol($proto);
 
-                    quote_spanned! { g.field.span() =>
-                        module.field_fn(#protocol, #name, |s: &mut #ident, value: #ty| {
-                            s.#field_ident $op value;
-                        })?;
+                    if let Some(custom) = &g.protocol.custom {
+                        quote_spanned! { g.field.span() =>
+                            module.field_fn(#protocol, #name, #custom)?;
+                        }
+                    } else {
+                        quote_spanned! { g.field.span() =>
+                            module.field_fn(#protocol, #name, |s: &mut #ident, value: #ty| {
+                                s.#field_ident $op value;
+                            })?;
+                        }
                     }
                 }
             };
@@ -162,8 +170,12 @@ impl Context {
         for attr in attrs {
             for meta in self.get_rune_meta_items(attr)? {
                 match meta {
-                    Meta(Path(path)) if path == GET => {
+                    Meta(Path(path)) if path == COPY => {
+                        output.copy = true;
+                    }
+                    Meta(meta) if meta.path() == GET => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: |g| {
                                 let Generate {
                                     ident,
@@ -186,8 +198,9 @@ impl Context {
                             },
                         });
                     }
-                    Meta(Path(path)) if path == SET => {
+                    Meta(meta) if meta.path() == SET => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: |g| {
                                 let Generate {
                                     ident,
@@ -207,53 +220,65 @@ impl Context {
                             },
                         });
                     }
-                    Meta(Path(path)) if path == ADD_ASSIGN => {
+                    Meta(meta) if meta.path() == ADD_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_ADD_ASSIGN, +=),
                         });
                     }
-                    Meta(Path(path)) if path == SUB_ASSIGN => {
+                    Meta(meta) if meta.path() == SUB_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_SUB_ASSIGN, -=),
                         });
                     }
-                    Meta(Path(path)) if path == DIV_ASSIGN => {
+                    Meta(meta) if meta.path() == DIV_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_DIV_ASSIGN, /=),
                         });
                     }
-                    Meta(Path(path)) if path == MUL_ASSIGN => {
+                    Meta(meta) if meta.path() == MUL_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_MUL_ASSIGN, *=),
                         });
                     }
-                    Meta(Path(path)) if path == BIT_AND_ASSIGN => {
+                    Meta(meta) if meta.path() == BIT_AND_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_BIT_AND_ASSIGN, &=),
                         });
                     }
-                    Meta(Path(path)) if path == BIT_OR_ASSIGN => {
+                    Meta(meta) if meta.path() == BIT_OR_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_BIT_OR_ASSIGN, |=),
                         });
                     }
-                    Meta(Path(path)) if path == BIT_XOR_ASSIGN => {
+                    Meta(meta) if meta.path() == BIT_XOR_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_BIT_XOR_ASSIGN, ^=),
                         });
                     }
-                    Meta(Path(path)) if path == SHL_ASSIGN => {
+                    Meta(meta) if meta.path() == SHL_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_SHL_ASSIGN, <<=),
                         });
                     }
-                    Meta(Path(path)) if path == SHR_ASSIGN => {
+                    Meta(meta) if meta.path() == SHR_ASSIGN => {
                         output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
                             generate: generate_op!(PROTOCOL_SHR_ASSIGN, >>=),
                         });
                     }
-                    Meta(Path(path)) if path == COPY => {
-                        output.copy = true;
+                    Meta(meta) if meta.path() == REM_ASSIGN => {
+                        output.protocols.push(FieldProtocol {
+                            custom: self.parse_field_custom(meta)?,
+                            generate: generate_op!(PROTOCOL_REM_ASSIGN, %=),
+                        });
                     }
                     _ => {
                         self.errors
@@ -268,6 +293,30 @@ impl Context {
         Some(output)
     }
 
+    /// Parse path to custom field function.
+    fn parse_field_custom(&mut self, meta: syn::Meta) -> Option<Option<syn::Path>> {
+        let s = match meta {
+            Path(..) => return Some(None),
+            NameValue(syn::MetaNameValue {
+                lit: syn::Lit::Str(s),
+                ..
+            }) => s,
+            _ => {
+                self.errors
+                    .push(syn::Error::new(meta.span(), "unsupported meta"));
+                return None;
+            }
+        };
+
+        match s.parse_with(syn::Path::parse_mod_style) {
+            Ok(path) => Some(Some(path)),
+            Err(error) => {
+                self.errors.push(error);
+                None
+            }
+        }
+    }
+
     /// Parse field attributes.
     pub(crate) fn parse_derive_attrs(&mut self, attrs: &[syn::Attribute]) -> Option<DeriveAttrs> {
         let mut output = DeriveAttrs::default();
@@ -328,6 +377,7 @@ impl Context {
                     for protocol in &attrs.protocols {
                         installers.push((protocol.generate)(Generate {
                             context: self,
+                            protocol,
                             attrs: &attrs,
                             ident,
                             field,
diff --git a/crates/runestick-macros/src/internals.rs b/crates/runestick-macros/src/internals.rs
@@ -11,6 +11,7 @@ pub const NAME: Symbol = Symbol("name");
 
 pub const GET: Symbol = Symbol("get");
 pub const SET: Symbol = Symbol("set");
+pub const COPY: Symbol = Symbol("copy");
 
 pub const ADD_ASSIGN: Symbol = Symbol("add_assign");
 pub const SUB_ASSIGN: Symbol = Symbol("sub_assign");
@@ -21,8 +22,7 @@ pub const BIT_OR_ASSIGN: Symbol = Symbol("bit_or_assign");
 pub const BIT_XOR_ASSIGN: Symbol = Symbol("bit_xor_assign");
 pub const SHL_ASSIGN: Symbol = Symbol("shl_assign");
 pub const SHR_ASSIGN: Symbol = Symbol("shr_assign");
-
-pub const COPY: Symbol = Symbol("copy");
+pub const REM_ASSIGN: Symbol = Symbol("rem_assign");
 
 pub const PROTOCOL_GET: Symbol = Symbol("GET");
 pub const PROTOCOL_SET: Symbol = Symbol("SET");
@@ -35,6 +35,7 @@ pub const PROTOCOL_BIT_OR_ASSIGN: Symbol = Symbol("BIT_OR_ASSIGN");
 pub const PROTOCOL_BIT_XOR_ASSIGN: Symbol = Symbol("BIT_XOR_ASSIGN");
 pub const PROTOCOL_SHL_ASSIGN: Symbol = Symbol("SHL_ASSIGN");
 pub const PROTOCOL_SHR_ASSIGN: Symbol = Symbol("SHR_ASSIGN");
+pub const PROTOCOL_REM_ASSIGN: Symbol = Symbol("REM_ASSIGN");
 
 impl PartialEq<Symbol> for syn::Ident {
     fn eq(&self, word: &Symbol) -> bool {
diff --git a/crates/runestick/src/module.rs b/crates/runestick/src/module.rs
@@ -967,9 +967,7 @@ macro_rules! impl_register {
     (@return $stack:ident, $ret:ident, $ty:ty) => {
         let $ret = match $ret.to_value() {
             Ok($ret) => $ret,
-            Err(e) => return Err(VmError::from(VmErrorKind::BadReturn {
-                error: e.unpack_critical()?,
-            })),
+            Err(e) => return Err(VmError::from(e.unpack_critical()?)),
         };
 
         $stack.push($ret);
diff --git a/crates/runestick/src/vm_error.rs b/crates/runestick/src/vm_error.rs
@@ -215,11 +215,6 @@ pub enum VmErrorKind {
         error: VmError,
         arg: usize,
     },
-    #[error("bad return value: {error}")]
-    BadReturn {
-        #[source]
-        error: VmError,
-    },
     #[error("the index set operation `{target}[{index}] = {value}` is not supported")]
     UnsupportedIndexSet {
         target: TypeInfo,
