Remove Position parameter from plugin call function.

codegen/src/function.rs

@@ -84,71 +84,91 @@ impl ExportedParams for ExportedFnParams {
         let mut skip = false;
         let mut special = FnSpecialAccess::None;
         for attr in attrs {
-            let crate::attrs::AttrItem { key, value, span: item_span } = attr;
+            let crate::attrs::AttrItem {
+                key,
+                value,
+                span: item_span,
+            } = attr;
             match (key.to_string().as_ref(), value) {
                 ("get", None) | ("set", None) | ("name", None) => {
                     return Err(syn::Error::new(key.span(), "requires value"))
-                },
+                }
                 ("name", Some(s)) if &s.value() == FN_IDX_GET => {
-                    return Err(syn::Error::new(item_span,
-                               "use attribute 'index_get' instead"))
-                },
+                    return Err(syn::Error::new(
+                        item_span,
+                        "use attribute 'index_get' instead",
+                    ))
+                }
                 ("name", Some(s)) if &s.value() == FN_IDX_SET => {
-                    return Err(syn::Error::new(item_span,
-                               "use attribute 'index_set' instead"))
-                },
+                    return Err(syn::Error::new(
+                        item_span,
+                        "use attribute 'index_set' instead",
+                    ))
+                }
                 ("name", Some(s)) if s.value().starts_with("get$") => {
-                    return Err(syn::Error::new(item_span,
-                               format!("use attribute 'getter = \"{}\"' instead",
-                                       &s.value()["get$".len()..])))
-                },
+                    return Err(syn::Error::new(
+                        item_span,
+                        format!(
+                            "use attribute 'getter = \"{}\"' instead",
+                            &s.value()["get$".len()..]
+                        ),
+                    ))
+                }
                 ("name", Some(s)) if s.value().starts_with("set$") => {
-                    return Err(syn::Error::new(item_span,
-                               format!("use attribute 'setter = \"{}\"' instead",
-                                       &s.value()["set$".len()..])))
-                },
+                    return Err(syn::Error::new(
+                        item_span,
+                        format!(
+                            "use attribute 'setter = \"{}\"' instead",
+                            &s.value()["set$".len()..]
+                        ),
+                    ))
+                }
                 ("name", Some(s)) if s.value().contains('$') => {
-                    return Err(syn::Error::new(s.span(),
-                               "Rhai function names may not contain dollar sign"))
-                },
+                    return Err(syn::Error::new(
+                        s.span(),
+                        "Rhai function names may not contain dollar sign",
+                    ))
+                }
                 ("name", Some(s)) if s.value().contains('.') => {
-                    return Err(syn::Error::new(s.span(),
-                               "Rhai function names may not contain dot"))
-                },
-                ("name", Some(s)) => {
-                    name.push(s.value())
-                },
-                ("set", Some(s)) => special = match special {
-                    FnSpecialAccess::None =>
-                        FnSpecialAccess::Property(Property::Set(syn::Ident::new(&s.value(),
-                                                                s.span()))),
-                    _ => {
-                        return Err(syn::Error::new(item_span.span(), "conflicting setter"))
+                    return Err(syn::Error::new(
+                        s.span(),
+                        "Rhai function names may not contain dot",
+                    ))
+                }
+                ("name", Some(s)) => name.push(s.value()),
+                ("set", Some(s)) => {
+                    special = match special {
+                        FnSpecialAccess::None => FnSpecialAccess::Property(Property::Set(
+                            syn::Ident::new(&s.value(), s.span()),
+                        )),
+                        _ => return Err(syn::Error::new(item_span.span(), "conflicting setter")),
                     }
-                },
-                ("get", Some(s)) => special = match special {
-                    FnSpecialAccess::None =>
-                        FnSpecialAccess::Property(Property::Get(syn::Ident::new(&s.value(),
-                                                                s.span()))),
-                    _ => {
-                        return Err(syn::Error::new(item_span.span(), "conflicting getter"))
+                }
+                ("get", Some(s)) => {
+                    special = match special {
+                        FnSpecialAccess::None => FnSpecialAccess::Property(Property::Get(
+                            syn::Ident::new(&s.value(), s.span()),
+                        )),
+                        _ => return Err(syn::Error::new(item_span.span(), "conflicting getter")),
                     }
-                },
-                ("index_get", None) => special = match special {
-                    FnSpecialAccess::None =>
-                        FnSpecialAccess::Index(Index::Get),
-                    _ => {
-                        return Err(syn::Error::new(item_span.span(), "conflicting index_get"))
+                }
+                ("index_get", None) => {
+                    special = match special {
+                        FnSpecialAccess::None => FnSpecialAccess::Index(Index::Get),
+                        _ => {
+                            return Err(syn::Error::new(item_span.span(), "conflicting index_get"))
+                        }
                     }
-                },
+                }
 
-                ("index_set", None) => special = match special {
-                    FnSpecialAccess::None =>
-                        FnSpecialAccess::Index(Index::Set),
-                    _ => {
-                        return Err(syn::Error::new(item_span.span(), "conflicting index_set"))
+                ("index_set", None) => {
+                    special = match special {
+                        FnSpecialAccess::None => FnSpecialAccess::Index(Index::Set),
+                        _ => {
+                            return Err(syn::Error::new(item_span.span(), "conflicting index_set"))
+                        }
                     }
-                },
+                }
                 ("return_raw", None) => return_raw = true,
                 ("index_get", Some(s)) | ("index_set", Some(s)) | ("return_raw", Some(s)) => {
                     return Err(syn::Error::new(s.span(), "extraneous value"))
@@ -327,26 +347,40 @@ impl ExportedFn {
     }
 
     pub(crate) fn exported_names(&self) -> Vec<syn::LitStr> {
-        let mut literals = self.params.name.as_ref()
-            .map(|v| v.iter()
-                 .map(|s| syn::LitStr::new(s, proc_macro2::Span::call_site())).collect())
+        let mut literals = self
+            .params
+            .name
+            .as_ref()
+            .map(|v| {
+                v.iter()
+                    .map(|s| syn::LitStr::new(s, proc_macro2::Span::call_site()))
+                    .collect()
+            })
             .unwrap_or_else(|| Vec::new());
 
         match self.params.special {
-            FnSpecialAccess::None => {},
-            FnSpecialAccess::Property(Property::Get(ref g)) =>
-                literals.push(syn::LitStr::new(&format!("get${}", g.to_string()), g.span())),
-            FnSpecialAccess::Property(Property::Set(ref s)) =>
-                literals.push(syn::LitStr::new(&format!("set${}", s.to_string()), s.span())),
-            FnSpecialAccess::Index(Index::Get) =>
-                literals.push(syn::LitStr::new(FN_IDX_GET, proc_macro2::Span::call_site())),
-            FnSpecialAccess::Index(Index::Set) =>
-                literals.push(syn::LitStr::new(FN_IDX_SET, proc_macro2::Span::call_site())),
+            FnSpecialAccess::None => {}
+            FnSpecialAccess::Property(Property::Get(ref g)) => literals.push(syn::LitStr::new(
+                &format!("get${}", g.to_string()),
+                g.span(),
+            )),
+            FnSpecialAccess::Property(Property::Set(ref s)) => literals.push(syn::LitStr::new(
+                &format!("set${}", s.to_string()),
+                s.span(),
+            )),
+            FnSpecialAccess::Index(Index::Get) => {
+                literals.push(syn::LitStr::new(FN_IDX_GET, proc_macro2::Span::call_site()))
+            }
+            FnSpecialAccess::Index(Index::Set) => {
+                literals.push(syn::LitStr::new(FN_IDX_SET, proc_macro2::Span::call_site()))
+            }
         }
 
         if literals.is_empty() {
-            literals.push(syn::LitStr::new(&self.signature.ident.to_string(),
-                                           self.signature.ident.span()));
+            literals.push(syn::LitStr::new(
+                &self.signature.ident.to_string(),
+                self.signature.ident.span(),
+            ));
         }
 
         literals
@@ -394,53 +428,61 @@ impl ExportedFn {
 
         match params.special {
             // 2a. Property getters must take only the subject as an argument.
-            FnSpecialAccess::Property(Property::Get(_)) if self.arg_count() != 1 =>
+            FnSpecialAccess::Property(Property::Get(_)) if self.arg_count() != 1 => {
                 return Err(syn::Error::new(
                     self.signature.span(),
                     "property getter requires exactly 1 argument",
-                )),
+                ))
+            }
             // 2b. Property getters must return a value.
-            FnSpecialAccess::Property(Property::Get(_)) if self.return_type().is_none() =>
+            FnSpecialAccess::Property(Property::Get(_)) if self.return_type().is_none() => {
                 return Err(syn::Error::new(
                     self.signature.span(),
-                    "property getter must return a value"
-                )),
+                    "property getter must return a value",
+                ))
+            }
             // 3a. Property setters must take the subject and a new value as arguments.
-            FnSpecialAccess::Property(Property::Set(_)) if self.arg_count() != 2 =>
+            FnSpecialAccess::Property(Property::Set(_)) if self.arg_count() != 2 => {
                 return Err(syn::Error::new(
                     self.signature.span(),
                     "property setter requires exactly 2 arguments",
-                )),
+                ))
+            }
             // 3b. Property setters must return nothing.
-            FnSpecialAccess::Property(Property::Set(_)) if self.return_type().is_some() =>
+            FnSpecialAccess::Property(Property::Set(_)) if self.return_type().is_some() => {
                 return Err(syn::Error::new(
                     self.signature.span(),
-                    "property setter must return no value"
-                )),
+                    "property setter must return no value",
+                ))
+            }
             // 4a. Index getters must take the subject and the accessed "index" as arguments.
-            FnSpecialAccess::Index(Index::Get) if self.arg_count() != 2 =>
+            FnSpecialAccess::Index(Index::Get) if self.arg_count() != 2 => {
                 return Err(syn::Error::new(
                     self.signature.span(),
                     "index getter requires exactly 2 arguments",
-                )),
+                ))
+            }
             // 4b. Index getters must return a value.
-            FnSpecialAccess::Index(Index::Get) if self.return_type().is_none() =>
+            FnSpecialAccess::Index(Index::Get) if self.return_type().is_none() => {
                 return Err(syn::Error::new(
                     self.signature.span(),
-                    "index getter must return a value"
-                )),
+                    "index getter must return a value",
+                ))
+            }
             // 5a. Index setters must take the subject, "index", and new value as arguments.
-            FnSpecialAccess::Index(Index::Set) if self.arg_count() != 3 =>
+            FnSpecialAccess::Index(Index::Set) if self.arg_count() != 3 => {
                 return Err(syn::Error::new(
                     self.signature.span(),
                     "index setter requires exactly 3 arguments",
-                )),
+                ))
+            }
             // 5b. Index setters must return nothing.
-            FnSpecialAccess::Index(Index::Set) if self.return_type().is_some() =>
+            FnSpecialAccess::Index(Index::Set) if self.return_type().is_some() => {
                 return Err(syn::Error::new(
                     self.signature.span(),
-                    "index setter must return no value"
-                )),
+                    "index setter must return no value",
+                ))
+            }
             _ => {}
         }
 
@@ -685,7 +727,7 @@ impl ExportedFn {
         quote! {
             impl PluginFunction for #type_name {
                 fn call(&self,
-                        args: &mut [&mut Dynamic], pos: Position
+                        args: &mut [&mut Dynamic]
                 ) -> Result<Dynamic, Box<EvalAltResult>> {
                     debug_assert_eq!(args.len(), #arg_count,
                                      "wrong arg count: {} != {}",