ARROW-10628: [Rust] flag clippy warnings as errors

ci/scripts/rust_lint.sh

@@ -17,10 +17,14 @@
 # specific language governing permissions and limitations
 # under the License.
 
+# Entrypoint to run rust linter on CI (automated tests)
+#
+# Usage: rust_lint.sh <arrow checkout directory>
+
 set -e
 
 source_dir=${1}/rust
 
 pushd ${source_dir}/arrow
-    cargo clippy -- -A clippy::redundant_field_names
+    cargo clippy --all-targets --workspace -- -D warnings -A clippy::redundant_field_names
 popd

rust/arrow/benches/array_from_vec.rs

@@ -68,12 +68,12 @@ fn struct_array_values(
 
 fn struct_array_from_vec(
     field1: &str,
-    strings: &Vec<Option<&str>>,
+    strings: &[Option<&str>],
     field2: &str,
-    ints: &Vec<Option<i32>>,
+    ints: &[Option<i32>],
 ) {
-    let strings: ArrayRef = Arc::new(StringArray::from(strings.clone()));
-    let ints: ArrayRef = Arc::new(Int32Array::from(ints.clone()));
+    let strings: ArrayRef = Arc::new(StringArray::from(strings.to_owned()));
+    let ints: ArrayRef = Arc::new(Int32Array::from(ints.to_owned()));
 
     criterion::black_box(
         StructArray::try_from(vec![(field1, strings), (field2, ints)]).unwrap(),

rust/arrow/benches/csv_writer.rs

@@ -56,6 +56,7 @@ fn record_batches_to_csv() {
     let file = File::create("target/bench_write_csv.csv").unwrap();
     let mut writer = csv::Writer::new(file);
     let batches = vec![&b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b];
+    #[allow(clippy::unit_arg)]
     criterion::black_box(for batch in batches {
         writer.write(batch).unwrap()
     });

rust/arrow/benches/take_kernels.rs

@@ -41,7 +41,7 @@ where
     let array: PrimitiveArray<T> = seedable_rng()
         .sample_iter(&Standard)
         .take(size)
-        .map(|v| Some(v))
+        .map(Some)
         .collect();
 
     Arc::new(array) as ArrayRef

rust/arrow/src/array/iterator.rs

@@ -227,7 +227,7 @@ mod tests {
             .map(|e| {
                 e.and_then(|e| {
                     let mut a = e.to_string();
-                    a.push_str("b");
+                    a.push('b');
                     Some(a)
                 })
             })

rust/arrow/src/buffer.rs

@@ -780,7 +780,7 @@ impl MutableBuffer {
     /// `new_len` will be zeroed out.
     ///
     /// If `new_len` is less than `len`, the buffer will be truncated.
-    pub fn resize(&mut self, new_len: usize) -> () {
+    pub fn resize(&mut self, new_len: usize) {
         if new_len > self.len {
             self.reserve(new_len);
         } else {

rust/arrow/src/compute/kernels/substring.rs

@@ -161,19 +161,18 @@ mod tests {
             ),
         ];
 
-        cases
-            .into_iter()
-            .map(|(array, start, length, expected)| {
+        cases.into_iter().try_for_each::<_, Result<()>>(
+            |(array, start, length, expected)| {
                 let array = T::from(array);
-                let result = substring(&array, start, &length)?;
+                let result: ArrayRef = substring(&array, start, &length)?;
                 assert_eq!(array.len(), result.len());
 
                 let result = result.as_any().downcast_ref::<T>().unwrap();
                 let expected = T::from(expected);
                 assert_eq!(&expected, result);
                 Ok(())
-            })
-            .collect::<Result<()>>()?;
+            },
+        )?;
 
         Ok(())
     }
@@ -243,18 +242,17 @@ mod tests {
             ),
         ];
 
-        cases
-            .into_iter()
-            .map(|(array, start, length, expected)| {
+        cases.into_iter().try_for_each::<_, Result<()>>(
+            |(array, start, length, expected)| {
                 let array = StringArray::from(array);
                 let result = substring(&array, start, &length)?;
                 assert_eq!(array.len(), result.len());
                 let result = result.as_any().downcast_ref::<StringArray>().unwrap();
                 let expected = StringArray::from(expected);
                 assert_eq!(&expected, result,);
                 Ok(())
-            })
-            .collect::<Result<()>>()?;
+            },
+        )?;
 
         Ok(())
     }

rust/arrow/src/util/bit_chunk_iterator.rs

@@ -250,7 +250,7 @@ mod tests {
 
         assert_eq!(63, bitchunks.remainder_len());
         assert_eq!(
-            0b1000000_00111111_11000000_00111111_11000000_00111111_11000000_00111111,
+            0b100_0000_0011_1111_1100_0000_0011_1111_1100_0000_0011_1111_1100_0000_0011_1111,
             bitchunks.remainder_bits()
         );
     }

rust/datafusion/examples/simple_udaf.rs

@@ -163,7 +163,7 @@ async fn main() -> Result<()> {
         .unwrap();
 
     // verify that the calculation is correct
-    assert_eq!(result.value(0), 8.0);
+    assert!((result.value(0) - 8.0).abs() < f64::EPSILON);
     println!("The geometric mean of [2,4,8,64] is {}", result.value(0));
 
     Ok(())

rust/datafusion/src/bin/repl.rs

@@ -85,7 +85,7 @@ pub async fn main() {
             }
             Ok(ref line) => {
                 query.push_str(line);
-                query.push_str(" ");
+                query.push(' ');
             }
             Err(_) => {
                 break;

rust/datafusion/tests/dataframe.rs

@@ -164,9 +164,9 @@ async fn custom_source_dataframe() -> Result<()> {
                 assert_eq!(table_schema.fields().len(), 2);
                 assert_eq!(projected_schema.fields().len(), 1);
             }
-            _ => assert!(false, "input to projection should be TableScan"),
+            _ => panic!("input to projection should be TableScan"),
         },
-        _ => assert!(false, "expect optimized_plan to be projection"),
+        _ => panic!("expect optimized_plan to be projection"),
     }
 
     let expected = "Projection: #c2\

rust/datafusion/tests/sql.rs

@@ -82,9 +82,9 @@ async fn nyc() -> Result<()> {
                 assert_eq!(projected_schema.field(0).name(), "passenger_count");
                 assert_eq!(projected_schema.field(1).name(), "fare_amount");
             }
-            _ => assert!(false),
+            _ => unreachable!(),
         },
-        _ => assert!(false),
+        _ => unreachable!(false),
     }
 
     Ok(())

rust/datafusion/tests/user_defined_plan.rs

@@ -91,7 +91,7 @@ use async_trait::async_trait;
 async fn exec_sql(ctx: &mut ExecutionContext, sql: &str) -> Result<String> {
     let df = ctx.sql(sql)?;
     let batches = df.collect().await?;
-    pretty_format_batches(&batches).map_err(|e| DataFusionError::ArrowError(e))
+    pretty_format_batches(&batches).map_err(DataFusionError::ArrowError)
 }
 
 /// Create a test table.
@@ -494,7 +494,7 @@ impl Stream for TopKReader {
 
         // take this as immutable
         let k = self.k;
-        let schema = self.schema().clone();
+        let schema = self.schema();
 
         let top_values = self
             .input

rust/parquet/src/arrow/arrow_writer.rs

@@ -194,56 +194,54 @@ fn write_leaves(
                 );
             }
 
-            match (&**key_type, &**value_type, &mut col_writer) {
-                (UInt8, UInt32, Int32ColumnWriter(writer)) => {
-                    let typed_array = array
-                        .as_any()
-                        .downcast_ref::<arrow_array::UInt8DictionaryArray>()
-                        .expect("Unable to get dictionary array");
-
-                    let keys = typed_array.keys();
-
-                    let value_buffer = typed_array.values();
-                    let value_array =
-                        arrow::compute::cast(&value_buffer, &ArrowDataType::Int32)?;
-
-                    let values = value_array
-                        .as_any()
-                        .downcast_ref::<arrow_array::Int32Array>()
-                        .unwrap();
-
-                    use std::convert::TryFrom;
-                    // This removes NULL values from the keys, but
-                    // they're encoded by the levels, so that's fine.
-                    let materialized_values: Vec<_> = keys
-                        .into_iter()
-                        .flatten()
-                        .map(|key| {
-                            usize::try_from(key).unwrap_or_else(|k| {
-                                panic!("key {} does not fit in usize", k)
-                            })
-                        })
-                        .map(|key| values.value(key))
-                        .collect();
-
-                    let materialized_primitive_array =
-                        PrimitiveArray::<arrow::datatypes::Int32Type>::from(
-                            materialized_values,
-                        );
-
-                    writer.write_batch(
-                        get_numeric_array_slice::<Int32Type, _>(
-                            &materialized_primitive_array,
-                        )
-                        .as_slice(),
-                        Some(levels.definition.as_slice()),
-                        levels.repetition.as_deref(),
-                    )?;
-                    row_group_writer.close_column(col_writer)?;
-
-                    return Ok(());
-                }
-                _ => {}
+            if let (UInt8, UInt32, Int32ColumnWriter(writer)) =
+                (&**key_type, &**value_type, &mut col_writer)
+            {
+                let typed_array = array
+                    .as_any()
+                    .downcast_ref::<arrow_array::UInt8DictionaryArray>()
+                    .expect("Unable to get dictionary array");
+
+                let keys = typed_array.keys();
+
+                let value_buffer = typed_array.values();
+                let value_array =
+                    arrow::compute::cast(&value_buffer, &ArrowDataType::Int32)?;
+
+                let values = value_array
+                    .as_any()
+                    .downcast_ref::<arrow_array::Int32Array>()
+                    .unwrap();
+
+                use std::convert::TryFrom;
+                // This removes NULL values from the keys, but
+                // they're encoded by the levels, so that's fine.
+                let materialized_values: Vec<_> = keys
+                    .into_iter()
+                    .flatten()
+                    .map(|key| {
+                        usize::try_from(key)
+                            .unwrap_or_else(|k| panic!("key {} does not fit in usize", k))
+                    })
+                    .map(|key| values.value(key))
+                    .collect();
+
+                let materialized_primitive_array =
+                    PrimitiveArray::<arrow::datatypes::Int32Type>::from(
+                        materialized_values,
+                    );
+
+                writer.write_batch(
+                    get_numeric_array_slice::<Int32Type, _>(
+                        &materialized_primitive_array,
+                    )
+                    .as_slice(),
+                    Some(levels.definition.as_slice()),
+                    levels.repetition.as_deref(),
+                )?;
+                row_group_writer.close_column(col_writer)?;
+
+                return Ok(());
             }
 
             dispatch_dictionary!(

rust/parquet/src/bin/parquet-rowcount.rs

@@ -57,8 +57,7 @@ fn main() {
         process::exit(1);
     }
 
-    for i in 1..args.len() {
-        let filename = args[i].clone();
+    for filename in args {
         let path = Path::new(&filename);
         let file = File::open(&path).unwrap();
         let parquet_reader = SerializedFileReader::new(file).unwrap();

rust/parquet/src/util/cursor.rs

@@ -79,6 +79,11 @@ impl SliceableCursor {
     pub fn len(&self) -> u64 {
         self.length as u64
     }
+
+    /// return true if the cursor is empty (self.len() == 0)
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
 }
 
 /// Implementation inspired by std::io::Cursor

rust/parquet_derive/src/parquet_field.rs

@@ -252,6 +252,8 @@ impl Field {
     }
 }
 
+#[allow(clippy::enum_variant_names)]
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, PartialEq)]
 enum Type {
     Array(Box<Type>),