Set Native errors as default for macro invocation errors

Summary: Errors coming from Starlark macro invocations should be Native errors by default unless it is another starlark error already

Reviewed By: stepancheg

Differential Revision: D63873160

fbshipit-source-id: 4e4cc26b5b613386eaf244fddd1de38943d91c44

starlark/src/__derive_refs.rs

@@ -28,6 +28,7 @@ pub mod serde {
 }
 pub use inventory;
 pub mod components;
+pub mod invoke_macro_error;
 pub mod param_spec;
 pub mod parse_args;
 pub mod sig;

starlark/src/__derive_refs/invoke_macro_error.rs

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2018 The Starlark in Rust Authors.
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// Trait used to convert error returned from native function into `starlark::Error`.
+pub trait InvokeMacroError {
+    fn into_starlark_error(self) -> crate::Error;
+}
+
+/// This implementation should not be used by starlark itself:
+/// starlark native functions should not return `anyhow::Error`,
+/// and should not convert to `ErrorKind::Native`.
+impl InvokeMacroError for anyhow::Error {
+    #[cold]
+    fn into_starlark_error(self) -> crate::Error {
+        crate::Error::new_native(self)
+    }
+}
+
+impl InvokeMacroError for crate::Error {
+    #[cold]
+    fn into_starlark_error(self) -> crate::Error {
+        self
+    }
+}

starlark_derive/src/module/render/fun.rs

@@ -315,9 +315,7 @@ pub(crate) fn render_fun(x: StarFun) -> syn::Result<syn::Stmt> {
                 #prepare
                 match Self::invoke_impl(#( #invoke_args, )*) {
                     Ok(v) => Ok(eval.heap().alloc(v)),
-                    // The `.into()` is an `anyhow -> anyhow` conversion if the return type is `anyhow`
-                    #[allow(clippy::useless_conversion)]
-                    Err(e) => Err(e.into()),
+                    Err(e) => Err(starlark::__derive_refs::invoke_macro_error::InvokeMacroError::into_starlark_error(e)),
                 }
             }
         }