Improved labeled error from plugins (#437)

* improved labeled error from plugins

* corrected span

crates/nu_plugin_example/src/main.rs

@@ -1,5 +1,5 @@
-use nu_plugin::{serve_plugin, EvaluatedCall, Plugin};
-use nu_protocol::{Category, ShellError, Signature, SyntaxShape, Value};
+use nu_plugin::{serve_plugin, EvaluatedCall, LabeledError, Plugin};
+use nu_protocol::{Category, Signature, SyntaxShape, Value};
 
 fn main() {
     serve_plugin(&mut Example {})
@@ -29,7 +29,16 @@ impl Plugin for Example {
                 .switch("flag", "a flag for the signature", Some('f'))
                 .optional("opt", SyntaxShape::Int, "Optional number")
                 .named("named", SyntaxShape::String, "named string", Some('n'))
-                .rest("rest", SyntaxShape::Int, "rest value int")
+                .rest("rest", SyntaxShape::String, "rest value string")
+                .category(Category::Experimental),
+            Signature::build("test-3")
+                .desc("Signature test 3 for plugin. Returns labeled error")
+                .required("a", SyntaxShape::Int, "required integer value")
+                .required("b", SyntaxShape::String, "required string value")
+                .switch("flag", "a flag for the signature", Some('f'))
+                .optional("opt", SyntaxShape::Int, "Optional number")
+                .named("named", SyntaxShape::String, "named string", Some('n'))
+                .rest("rest", SyntaxShape::String, "rest value string")
                 .category(Category::Experimental),
         ]
     }
@@ -39,25 +48,26 @@ impl Plugin for Example {
         name: &str,
         call: &EvaluatedCall,
         input: &Value,
-    ) -> Result<Value, ShellError> {
+    ) -> Result<Value, LabeledError> {
         // You can use the name to identify what plugin signature was called
         match name {
             "test-1" => test1(call, input),
             "test-2" => test2(call, input),
-            _ => Err(ShellError::LabeledError(
-                "Plugin call with wrong name signature".into(),
-                "using the wrong signature".into(),
-                call.head,
-            )),
+            "test-3" => test3(call, input),
+            _ => Err(LabeledError {
+                label: "Plugin call with wrong name signature".into(),
+                msg: "using the wrong signature".into(),
+                span: Some(call.head),
+            }),
         }
     }
 }
 
-fn test1(call: &EvaluatedCall, input: &Value) -> Result<Value, ShellError> {
+fn print_values(index: u32, call: &EvaluatedCall, input: &Value) -> Result<(), LabeledError> {
     // Note. When debugging your plugin, you may want to print something to the console
     // Use the eprintln macro to print your messages. Trying to print to stdout will
     // cause a decoding error for your message
-    eprintln!("Calling test1 signature");
+    eprintln!("Calling test {} signature", index);
     eprintln!("value received {:?}", input);
 
     // To extract the arguments from the Call object you can use the functions req, has_flag,
@@ -90,36 +100,17 @@ fn test1(call: &EvaluatedCall, input: &Value) -> Result<Value, ShellError> {
         None => eprintln!("No named value found"),
     }
 
+    Ok(())
+}
+
+fn test1(call: &EvaluatedCall, input: &Value) -> Result<Value, LabeledError> {
+    print_values(1, call, input)?;
+
     Ok(Value::Nothing { span: call.head })
 }
 
-fn test2(call: &EvaluatedCall, input: &Value) -> Result<Value, ShellError> {
-    eprintln!("Calling test1 signature");
-    eprintln!("value received {:?}", input);
-
-    eprintln!("Arguments received");
-    let a: i64 = call.req(0)?;
-    let b: String = call.req(1)?;
-    let flag = call.has_flag("flag");
-    let opt: Option<i64> = call.opt(2)?;
-    let named: Option<String> = call.get_flag("named")?;
-    let rest: Vec<i64> = call.rest(3)?;
-
-    eprintln!("Required values");
-    eprintln!("a: {:}", a);
-    eprintln!("b: {:}", b);
-    eprintln!("flag: {:}", flag);
-    eprintln!("rest: {:?}", rest);
-
-    match opt {
-        Some(v) => eprintln!("Found optional value opt: {:}", v),
-        None => eprintln!("No optional value found"),
-    }
-
-    match named {
-        Some(v) => eprintln!("Named value: {:?}", v),
-        None => eprintln!("No named value found"),
-    }
+fn test2(call: &EvaluatedCall, input: &Value) -> Result<Value, LabeledError> {
+    print_values(2, call, input)?;
 
     let cols = vec!["one".to_string(), "two".to_string(), "three".to_string()];
 
@@ -145,3 +136,13 @@ fn test2(call: &EvaluatedCall, input: &Value) -> Result<Value, ShellError> {
         span: call.head,
     })
 }
+
+fn test3(call: &EvaluatedCall, input: &Value) -> Result<Value, LabeledError> {
+    print_values(3, call, input)?;
+
+    Err(LabeledError {
+        label: "ERROR from plugin".into(),
+        msg: "error message pointing to call head span".into(),
+        span: Some(call.head),
+    })
+}