Add has_context to plugin functions.

src/func/call.rs

@@ -401,19 +401,19 @@ impl Engine {
             let is_method = func.is_method();
             let src = source.as_ref().map(|s| s.as_str());
 
+            let context = if func.has_context() {
+                Some((self, name, src, &*global, pos).into())
+            } else {
+                None
+            };
+
             let mut _result = if let Some(f) = func.get_plugin_fn() {
                 if !f.is_pure() && !args.is_empty() && args[0].is_read_only() {
                     Err(ERR::ErrorNonPureMethodCallOnConstant(name.to_string(), pos).into())
                 } else {
-                    let context = (self, name, src, &*global, pos).into();
                     f.call(context, args)
                 }
             } else if let Some(f) = func.get_native_fn() {
-                let context = if func.has_context() {
-                    Some((self, name, src, &*global, pos).into())
-                } else {
-                    None
-                };
                 f(context, args)
             } else {
                 unreachable!();
@@ -1390,8 +1390,12 @@ impl Engine {
             }
 
             Some(f) if f.is_plugin_fn() => {
-                let context = (self, fn_name, module.id(), &*global, pos).into();
                 let f = f.get_plugin_fn().expect("plugin function");
+                let context = if f.has_context() {
+                    Some((self, fn_name, module.id(), &*global, pos).into())
+                } else {
+                    None
+                };
                 if !f.is_pure() && !args.is_empty() && args[0].is_read_only() {
                     Err(ERR::ErrorNonPureMethodCallOnConstant(fn_name.to_string(), pos).into())
                 } else {

src/func/callable_function.rs

@@ -142,7 +142,8 @@ impl CallableFunction {
     pub fn has_context(&self) -> bool {
         match self {
             Self::Pure(.., ctx) | Self::Method(.., ctx) => *ctx,
-            Self::Plugin(..) | Self::Iterator(..) => false,
+            Self::Plugin(f) => f.has_context(),
+            Self::Iterator(..) => false,
             #[cfg(not(feature = "no_function"))]
             Self::Script(..) => false,
         }

src/func/plugin.rs

@@ -24,12 +24,16 @@ pub use rhai_codegen::{export_fn, register_exported_fn};
 /// Use the `#[export_module]` and `#[export_fn]` procedural attributes instead.
 pub trait PluginFunction {
     /// Call the plugin function with the arguments provided.
-    fn call(&self, context: NativeCallContext, args: &mut FnCallArgs) -> RhaiResult;
+    fn call(&self, context: Option<NativeCallContext>, args: &mut FnCallArgs) -> RhaiResult;
 
     /// Is this plugin function a method?
     #[must_use]
     fn is_method_call(&self) -> bool;
 
+    /// Does this plugin function contain a [`NativeCallContext`] parameter?
+    #[must_use]
+    fn has_context(&self) -> bool;
+
     /// Is this plugin function pure?
     ///
     /// This defaults to `true` such that any old implementation that has constant-checking code