feat: Makes error macros hygienic

datafusion/catalog-listing/src/helpers.rs

@@ -21,9 +21,7 @@ use std::mem;
 use std::sync::Arc;
 
 use datafusion_catalog::Session;
-use datafusion_common::{
-    assert_or_internal_err, DataFusionError, HashMap, Result, ScalarValue,
-};
+use datafusion_common::{assert_or_internal_err, HashMap, Result, ScalarValue};
 use datafusion_datasource::ListingTableUrl;
 use datafusion_datasource::PartitionedFile;
 use datafusion_expr::{lit, utils, BinaryExpr, Operator};

datafusion/common/src/error.rs

@@ -768,7 +768,7 @@ impl DataFusionErrorBuilder {
 macro_rules! unwrap_or_internal_err {
     ($Value: ident) => {
         $Value.ok_or_else(|| {
-            DataFusionError::Internal(format!(
+            $crate::DataFusionError::Internal(format!(
                 "{} should not be None",
                 stringify!($Value)
             ))
@@ -789,15 +789,15 @@ macro_rules! unwrap_or_internal_err {
 macro_rules! assert_or_internal_err {
     ($cond:expr) => {
         if !$cond {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::DataFusionError::Internal(format!(
                 "Assertion failed: {}",
                 stringify!($cond)
             )));
         }
     };
     ($cond:expr, $($arg:tt)+) => {
         if !$cond {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::DataFusionError::Internal(format!(
                 "Assertion failed: {}: {}",
                 stringify!($cond),
                 format!($($arg)+)
@@ -821,7 +821,7 @@ macro_rules! assert_eq_or_internal_err {
         let left_val = &$left;
         let right_val = &$right;
         if left_val != right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::DataFusionError::Internal(format!(
                 "Assertion failed: {} == {} (left: {:?}, right: {:?})",
                 stringify!($left),
                 stringify!($right),
@@ -834,7 +834,7 @@ macro_rules! assert_eq_or_internal_err {
         let left_val = &$left;
         let right_val = &$right;
         if left_val != right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::DataFusionError::Internal(format!(
                 "Assertion failed: {} == {} (left: {:?}, right: {:?}): {}",
                 stringify!($left),
                 stringify!($right),
@@ -861,7 +861,7 @@ macro_rules! assert_ne_or_internal_err {
         let left_val = &$left;
         let right_val = &$right;
         if left_val == right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::DataFusionError::Internal(format!(
                 "Assertion failed: {} != {} (left: {:?}, right: {:?})",
                 stringify!($left),
                 stringify!($right),
@@ -874,7 +874,7 @@ macro_rules! assert_ne_or_internal_err {
         let left_val = &$left;
         let right_val = &$right;
         if left_val == right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::DataFusionError::Internal(format!(
                 "Assertion failed: {} != {} (left: {:?}, right: {:?}): {}",
                 stringify!($left),
                 stringify!($right),
@@ -968,7 +968,7 @@ make_error!(resources_err, resources_datafusion_err, ResourcesExhausted);
 #[macro_export]
 macro_rules! sql_datafusion_err {
     ($ERR:expr $(; diagnostic = $DIAG:expr)?) => {{
-        let err = DataFusionError::SQL(Box::new($ERR), Some(DataFusionError::get_back_trace()));
+        let err = $crate::DataFusionError::SQL(Box::new($ERR), Some($crate::DataFusionError::get_back_trace()));
         $(
             let err = err.with_diagnostic($DIAG);
         )?
@@ -980,7 +980,7 @@ macro_rules! sql_datafusion_err {
 #[macro_export]
 macro_rules! sql_err {
     ($ERR:expr $(; diagnostic = $DIAG:expr)?) => {{
-        let err = datafusion_common::sql_datafusion_err!($ERR);
+        let err = $crate::sql_datafusion_err!($ERR);
         $(
             let err = err.with_diagnostic($DIAG);
         )?
@@ -992,7 +992,7 @@ macro_rules! sql_err {
 #[macro_export]
 macro_rules! arrow_datafusion_err {
     ($ERR:expr $(; diagnostic = $DIAG:expr)?) => {{
-        let err = DataFusionError::ArrowError(Box::new($ERR), Some(DataFusionError::get_back_trace()));
+        let err = $crate::DataFusionError::ArrowError(Box::new($ERR), Some($crate::DataFusionError::get_back_trace()));
         $(
             let err = err.with_diagnostic($DIAG);
         )?
@@ -1005,7 +1005,7 @@ macro_rules! arrow_datafusion_err {
 macro_rules! arrow_err {
     ($ERR:expr $(; diagnostic = $DIAG:expr)?) => {
     {
-        let err = datafusion_common::arrow_datafusion_err!($ERR);
+        let err = $crate::arrow_datafusion_err!($ERR);
         $(
             let err = err.with_diagnostic($DIAG);
         )?
@@ -1017,9 +1017,9 @@ macro_rules! arrow_err {
 #[macro_export]
 macro_rules! schema_datafusion_err {
     ($ERR:expr $(; diagnostic = $DIAG:expr)?) => {{
-        let err = $crate::error::DataFusionError::SchemaError(
+        let err = $crate::DataFusionError::SchemaError(
             Box::new($ERR),
-            Box::new(Some($crate::error::DataFusionError::get_back_trace())),
+            Box::new(Some($crate::DataFusionError::get_back_trace())),
         );
         $(
             let err = err.with_diagnostic($DIAG);
@@ -1032,9 +1032,9 @@ macro_rules! schema_datafusion_err {
 #[macro_export]
 macro_rules! schema_err {
     ($ERR:expr $(; diagnostic = $DIAG:expr)?) => {{
-        let err = $crate::error::DataFusionError::SchemaError(
+        let err = $crate::DataFusionError::SchemaError(
             Box::new($ERR),
-            Box::new(Some($crate::error::DataFusionError::get_back_trace())),
+            Box::new(Some($crate::DataFusionError::get_back_trace())),
         );
         $(
             let err = err.with_diagnostic($DIAG);

datafusion/common/src/utils/mod.rs

@@ -24,7 +24,7 @@ pub mod string_utils;
 
 use crate::assert_or_internal_err;
 use crate::error::{_exec_datafusion_err, _internal_datafusion_err};
-use crate::{DataFusionError, Result, ScalarValue};
+use crate::{Result, ScalarValue};
 use arrow::array::{
     Array, ArrayRef, FixedSizeListArray, LargeListArray, ListArray, OffsetSizeTrait,
     cast::AsArray,

datafusion/core/src/datasource/listing_table_factory.rs

@@ -28,7 +28,7 @@ use crate::datasource::listing::{
 use crate::execution::context::SessionState;
 
 use arrow::datatypes::DataType;
-use datafusion_common::{arrow_datafusion_err, plan_err, DataFusionError, ToDFSchema};
+use datafusion_common::{arrow_datafusion_err, plan_err, ToDFSchema};
 use datafusion_common::{config_datafusion_err, Result};
 use datafusion_expr::CreateExternalTable;
 

datafusion/core/tests/fuzz_cases/record_batch_generator.rs

@@ -34,7 +34,7 @@ use arrow_schema::{
     DECIMAL256_MAX_SCALE, DECIMAL32_MAX_PRECISION, DECIMAL32_MAX_SCALE,
     DECIMAL64_MAX_PRECISION, DECIMAL64_MAX_SCALE,
 };
-use datafusion_common::{arrow_datafusion_err, DataFusionError, Result};
+use datafusion_common::{arrow_datafusion_err, Result};
 use rand::{rng, rngs::StdRng, Rng, SeedableRng};
 use test_utils::array_gen::{
     BinaryArrayGenerator, BooleanArrayGenerator, DecimalArrayGenerator,

datafusion/datasource-avro/src/avro_to_arrow/arrow_array_reader.rs

@@ -46,7 +46,7 @@ use arrow::error::Result as ArrowResult;
 use arrow::record_batch::RecordBatch;
 use arrow::util::bit_util;
 use datafusion_common::arrow_err;
-use datafusion_common::error::{DataFusionError, Result};
+use datafusion_common::error::Result;
 use num_traits::NumCast;
 use std::collections::BTreeMap;
 use std::io::Read;

datafusion/datasource-parquet/src/access_plan.rs

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_common::{assert_eq_or_internal_err, DataFusionError, Result};
+use datafusion_common::{assert_eq_or_internal_err, Result};
 use parquet::arrow::arrow_reader::{RowSelection, RowSelector};
 use parquet::file::metadata::RowGroupMetaData;
 

datafusion/datasource/src/memory.rs

@@ -30,8 +30,7 @@ use crate::source::{DataSource, DataSourceExec};
 use arrow::array::{RecordBatch, RecordBatchOptions};
 use arrow::datatypes::{Schema, SchemaRef};
 use datafusion_common::{
-    assert_or_internal_err, plan_err, project_schema, DataFusionError, Result,
-    ScalarValue,
+    assert_or_internal_err, plan_err, project_schema, Result, ScalarValue,
 };
 use datafusion_execution::TaskContext;
 use datafusion_physical_expr::equivalence::project_orderings;

datafusion/datasource/src/sink.rs

@@ -24,7 +24,7 @@ use std::sync::Arc;
 
 use arrow::array::{ArrayRef, RecordBatch, UInt64Array};
 use arrow::datatypes::{DataType, Field, Schema, SchemaRef};
-use datafusion_common::{assert_eq_or_internal_err, DataFusionError, Result};
+use datafusion_common::{assert_eq_or_internal_err, Result};
 use datafusion_execution::TaskContext;
 use datafusion_physical_expr::{Distribution, EquivalenceProperties};
 use datafusion_physical_expr_common::sort_expr::{LexRequirement, OrderingRequirements};

datafusion/expr-common/src/interval_arithmetic.rs

@@ -3935,7 +3935,7 @@ mod tests {
         assert_eq!(interval.cardinality().unwrap(), 9178336040581070850);
 
         let interval = Interval::try_new(
-            ScalarValue::UInt64(Some(u64::MIN + 1)),
+            ScalarValue::UInt64(Some(1)),
             ScalarValue::UInt64(Some(u64::MAX)),
         )?;
         assert_eq!(interval.cardinality().unwrap(), u64::MAX);

datafusion/expr-common/src/statistics.rs

@@ -25,8 +25,8 @@ use arrow::array::ArrowNativeTypeOp;
 use arrow::datatypes::DataType;
 use datafusion_common::rounding::alter_fp_rounding_mode;
 use datafusion_common::{
-    DataFusionError, Result, ScalarValue, assert_eq_or_internal_err,
-    assert_ne_or_internal_err, assert_or_internal_err, internal_err, not_impl_err,
+    Result, ScalarValue, assert_eq_or_internal_err, assert_ne_or_internal_err,
+    assert_or_internal_err, internal_err, not_impl_err,
 };
 
 /// This object defines probabilistic distributions that encode uncertain

datafusion/expr/src/expr_schema.rs

@@ -835,9 +835,7 @@ mod tests {
     use super::*;
     use crate::{and, col, lit, not, or, out_ref_col_with_metadata, when};
 
-    use datafusion_common::{
-        assert_or_internal_err, DFSchema, DataFusionError, ScalarValue,
-    };
+    use datafusion_common::{assert_or_internal_err, DFSchema, ScalarValue};
 
     macro_rules! test_is_expr_nullable {
         ($EXPR_TYPE:ident) => {{

datafusion/expr/src/logical_plan/invariants.rs

@@ -18,7 +18,7 @@
 use datafusion_common::{
     assert_or_internal_err, plan_err,
     tree_node::{TreeNode, TreeNodeRecursion},
-    DFSchemaRef, DataFusionError, Result,
+    DFSchemaRef, Result,
 };
 
 use crate::{

datafusion/expr/src/udf.rs

@@ -26,8 +26,7 @@ use crate::{ColumnarValue, Documentation, Expr, Signature};
 use arrow::datatypes::{DataType, Field, FieldRef};
 use datafusion_common::config::ConfigOptions;
 use datafusion_common::{
-    assert_or_internal_err, not_impl_err, DataFusionError, ExprSchema, Result,
-    ScalarValue,
+    assert_or_internal_err, not_impl_err, ExprSchema, Result, ScalarValue,
 };
 use datafusion_expr_common::dyn_eq::{DynEq, DynHash};
 use datafusion_expr_common::interval_arithmetic::Interval;

datafusion/functions-aggregate-common/src/aggregate/count_distinct/dict.rs

@@ -17,8 +17,8 @@
 
 use arrow::array::{ArrayRef, BooleanArray};
 use arrow::downcast_dictionary_array;
+use datafusion_common::internal_err;
 use datafusion_common::{arrow_datafusion_err, ScalarValue};
-use datafusion_common::{internal_err, DataFusionError};
 use datafusion_expr_common::accumulator::Accumulator;
 
 #[derive(Debug)]

datafusion/functions-aggregate-common/src/aggregate/groups_accumulator.rs

@@ -32,7 +32,7 @@ use arrow::{
     compute::take_arrays,
     datatypes::UInt32Type,
 };
-use datafusion_common::{arrow_datafusion_err, DataFusionError, Result, ScalarValue};
+use datafusion_common::{arrow_datafusion_err, Result, ScalarValue};
 use datafusion_expr_common::accumulator::Accumulator;
 use datafusion_expr_common::groups_accumulator::{EmitTo, GroupsAccumulator};
 

datafusion/functions-aggregate/src/array_agg.rs

@@ -32,9 +32,7 @@ use datafusion_common::cast::as_list_array;
 use datafusion_common::utils::{
     compare_rows, get_row_at_idx, take_function_args, SingleRowListArrayBuilder,
 };
-use datafusion_common::{
-    assert_eq_or_internal_err, exec_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_eq_or_internal_err, exec_err, Result, ScalarValue};
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::utils::format_state_name;
 use datafusion_expr::{

datafusion/functions-aggregate/src/covariance.rs

@@ -24,8 +24,7 @@ use arrow::{
     datatypes::{DataType, Field},
 };
 use datafusion_common::{
-    downcast_value, plan_err, unwrap_or_internal_err, DataFusionError, Result,
-    ScalarValue,
+    downcast_value, plan_err, unwrap_or_internal_err, Result, ScalarValue,
 };
 use datafusion_expr::{
     function::{AccumulatorArgs, StateFieldsArgs},

datafusion/functions-aggregate/src/nth_value.rs

@@ -28,7 +28,7 @@ use arrow::datatypes::{DataType, Field, FieldRef, Fields};
 
 use datafusion_common::utils::{get_row_at_idx, SingleRowListArrayBuilder};
 use datafusion_common::{
-    assert_or_internal_err, exec_err, not_impl_err, DataFusionError, Result, ScalarValue,
+    assert_or_internal_err, exec_err, not_impl_err, Result, ScalarValue,
 };
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::utils::format_state_name;

datafusion/functions-aggregate/src/regr.rs

@@ -26,8 +26,7 @@ use arrow::{
     datatypes::Field,
 };
 use datafusion_common::{
-    downcast_value, plan_err, unwrap_or_internal_err, DataFusionError, HashMap, Result,
-    ScalarValue,
+    downcast_value, plan_err, unwrap_or_internal_err, HashMap, Result, ScalarValue,
 };
 use datafusion_doc::aggregate_doc_sections::DOC_SECTION_STATISTICAL;
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};

datafusion/functions-nested/src/position.rs

@@ -38,7 +38,7 @@ use datafusion_common::cast::{
     as_generic_list_array, as_int64_array, as_large_list_array, as_list_array,
 };
 use datafusion_common::{
-    assert_or_internal_err, exec_err, utils::take_function_args, DataFusionError, Result,
+    assert_or_internal_err, exec_err, utils::take_function_args, Result,
 };
 use itertools::Itertools;
 

datafusion/functions-nested/src/set_ops.rs

@@ -30,8 +30,7 @@ use arrow::row::{RowConverter, SortField};
 use datafusion_common::cast::{as_large_list_array, as_list_array};
 use datafusion_common::utils::ListCoercion;
 use datafusion_common::{
-    assert_eq_or_internal_err, exec_err, internal_err, utils::take_function_args,
-    DataFusionError, Result,
+    assert_eq_or_internal_err, exec_err, internal_err, utils::take_function_args, Result,
 };
 use datafusion_expr::{
     ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,

datafusion/functions-window/src/rank.rs

@@ -18,7 +18,6 @@
 //! Implementation of `rank`, `dense_rank`, and `percent_rank` window functions,
 //! which can be evaluated at runtime during query execution.
 
-use crate::define_udwf_and_expr;
 use arrow::datatypes::FieldRef;
 use datafusion_common::arrow::array::ArrayRef;
 use datafusion_common::arrow::array::{Float64Array, UInt64Array};

datafusion/functions/src/core/arrow_cast.rs

@@ -22,9 +22,7 @@ use arrow::error::ArrowError;
 use datafusion_common::{
     arrow_datafusion_err, exec_err, internal_err, Result, ScalarValue,
 };
-use datafusion_common::{
-    exec_datafusion_err, utils::take_function_args, DataFusionError,
-};
+use datafusion_common::{exec_datafusion_err, utils::take_function_args};
 use std::any::Any;
 
 use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};

datafusion/functions/src/core/greatest.rs

@@ -21,9 +21,7 @@ use arrow::buffer::BooleanBuffer;
 use arrow::compute::kernels::cmp;
 use arrow::compute::SortOptions;
 use arrow::datatypes::DataType;
-use datafusion_common::{
-    assert_eq_or_internal_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_eq_or_internal_err, Result, ScalarValue};
 use datafusion_doc::Documentation;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};

datafusion/functions/src/core/greatest_least_utils.rs

@@ -18,9 +18,7 @@
 use arrow::array::{Array, ArrayRef, BooleanArray};
 use arrow::compute::kernels::zip::zip;
 use arrow::datatypes::DataType;
-use datafusion_common::{
-    assert_or_internal_err, plan_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_or_internal_err, plan_err, Result, ScalarValue};
 use datafusion_expr_common::columnar_value::ColumnarValue;
 use datafusion_expr_common::type_coercion::binary::type_union_resolution;
 use std::sync::Arc;

datafusion/functions/src/core/least.rs

@@ -21,9 +21,7 @@ use arrow::buffer::BooleanBuffer;
 use arrow::compute::kernels::cmp;
 use arrow::compute::SortOptions;
 use arrow::datatypes::DataType;
-use datafusion_common::{
-    assert_eq_or_internal_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_eq_or_internal_err, Result, ScalarValue};
 use datafusion_doc::Documentation;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};

datafusion/functions/src/datetime/to_date.rs

@@ -20,7 +20,6 @@ use arrow::datatypes::DataType;
 use arrow::datatypes::DataType::*;
 use arrow::error::ArrowError::ParseError;
 use arrow::{array::types::Date32Type, compute::kernels::cast_utils::Parser};
-use datafusion_common::error::DataFusionError;
 use datafusion_common::{arrow_err, exec_err, internal_datafusion_err, Result};
 use datafusion_expr::{
     ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,

datafusion/functions/src/math/factorial.rs

@@ -26,7 +26,7 @@ use arrow::datatypes::DataType;
 use arrow::datatypes::DataType::Int64;
 
 use crate::utils::make_scalar_function;
-use datafusion_common::{arrow_datafusion_err, exec_err, DataFusionError, Result};
+use datafusion_common::{arrow_datafusion_err, exec_err, Result};
 use datafusion_expr::{
     ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,
     Volatility,