fix(ci): clippy complaints for the 1.46.0 release (#63)

I'm not sure how CI passed previously, it didn't report any errors with
linting but opening another PR resulted in lint failures.

Author: sbdchd

cli/src/reporter.rs

@@ -30,26 +30,26 @@ arg_enum! {
 
 #[derive(Debug)]
 pub enum DumpAstError {
-    PGQueryError(PGQueryError),
-    IoError(std::io::Error),
-    JsonError(serde_json::error::Error),
+    PGQuery(PGQueryError),
+    Io(std::io::Error),
+    Json(serde_json::error::Error),
 }
 
 impl std::convert::From<PGQueryError> for DumpAstError {
     fn from(e: PGQueryError) -> Self {
-        Self::PGQueryError(e)
+        Self::PGQuery(e)
     }
 }
 
 impl std::convert::From<std::io::Error> for DumpAstError {
     fn from(e: std::io::Error) -> Self {
-        Self::IoError(e)
+        Self::Io(e)
     }
 }
 
 impl std::convert::From<serde_json::error::Error> for DumpAstError {
     fn from(e: serde_json::error::Error) -> Self {
-        Self::JsonError(e)
+        Self::Json(e)
     }
 }
 

linter/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::shadow_unrelated)]
+#![allow(clippy::missing_errors_doc)]
 pub mod errors;
 pub mod rules;
 pub mod violations;
@@ -221,7 +223,7 @@ pub fn check_sql(
 mod test_rules {
     use super::*;
 
-    /// Ensure we handle both serializing and deserializing RuleViolationKind
+    /// Ensure we handle both serializing and deserializing `RuleViolationKind`
     #[test]
     fn test_parsing_rule_kind() {
         let rule_names = RULES.iter().map(|r| r.name.clone());
@@ -243,7 +245,7 @@ mod test_rules {
 
         let res = check_sql(sql, &["prefer-robust-stmts".into()]).expect("valid parsing of SQL");
         let mut prev_span_start = -1;
-        for violation in res.iter() {
+        for violation in &res {
             assert!(violation.span.start > prev_span_start);
             prev_span_start = violation.span.start;
         }

linter/src/rules/adding_field_with_default.rs

@@ -3,6 +3,7 @@ use squawk_parser::ast::{
     AlterTableCmds, AlterTableDef, ColumnDefConstraint, ConstrType, RootStmt, Stmt,
 };
 
+#[must_use]
 pub fn adding_field_with_default(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/adding_not_null_field.rs

@@ -3,6 +3,7 @@ use squawk_parser::ast::{
     AlterTableCmds, AlterTableDef, AlterTableType, ColumnDefConstraint, ConstrType, RootStmt, Stmt,
 };
 
+#[must_use]
 pub fn adding_not_nullable_field(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/bad_drop_database.rs

@@ -2,6 +2,7 @@ use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{RootStmt, Stmt};
 
 /// Brad's Rule aka ban dropping database statements.
+#[must_use]
 pub fn ban_drop_database(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/ban_char_field.rs

@@ -1,6 +1,7 @@
 use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{ColumnDefTypeName, QualifiedName, RootStmt, Stmt, TableElt};
 
+#[must_use]
 pub fn ban_char_type(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/changing_column_type.rs

@@ -1,6 +1,7 @@
 use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{AlterTableCmds, AlterTableType, RootStmt, Stmt};
 
+#[must_use]
 pub fn changing_column_type(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/constraint_missing_not_valid.rs

@@ -2,6 +2,7 @@ use crate::rules::utils::tables_created_in_transaction;
 use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{AlterTableCmds, AlterTableDef, RelationKind, RootStmt, Stmt};
 
+#[must_use]
 pub fn constraint_missing_not_valid(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     let tables_created = tables_created_in_transaction(tree);

linter/src/rules/disallow_unique_constraint.rs

@@ -2,6 +2,7 @@ use crate::rules::utils::tables_created_in_transaction;
 use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{AlterTableCmds, AlterTableDef, ConstrType, RelationKind, RootStmt, Stmt};
 
+#[must_use]
 pub fn disallow_unique_constraint(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let tables_created = tables_created_in_transaction(tree);
     let mut errs = vec![];

linter/src/rules/prefer_robust_stmts.rs

@@ -7,6 +7,7 @@ use squawk_parser::ast::{AlterTableCmds, RootStmt, Stmt, TransactionStmtKind};
 /// when we CREATE INDEX CONCURRENTLY, we should try and make those migrations
 /// more robust by using guards like `IF NOT EXISTS`. So if the migration fails
 /// halfway through, it can be rerun without human intervention.
+#[must_use]
 pub fn prefer_robust_stmts(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     let mut inside_transaction = false;

linter/src/rules/prefer_text_field.rs

@@ -4,6 +4,7 @@ use squawk_parser::ast::{ColumnDefTypeName, QualifiedName, RootStmt, Stmt, Table
 /// It's easier to update the check constraint on a text field than a varchar()
 /// size since the check constraint can use NOT VALID with a separate VALIDATE
 /// call.
+#[must_use]
 pub fn prefer_text_field(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/renaming_column.rs

@@ -1,6 +1,7 @@
 use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{ObjectType, RootStmt, Stmt};
 
+#[must_use]
 pub fn renaming_column(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/renaming_table.rs

@@ -1,6 +1,7 @@
 use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{ObjectType, RootStmt, Stmt};
 
+#[must_use]
 pub fn renaming_table(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let mut errs = vec![];
     for RootStmt::RawStmt(raw_stmt) in tree {

linter/src/rules/require_concurrent_index_creation.rs

@@ -2,6 +2,7 @@ use crate::rules::utils::tables_created_in_transaction;
 use crate::violations::{RuleViolation, RuleViolationKind};
 use squawk_parser::ast::{RelationKind, RootStmt, Stmt};
 
+#[must_use]
 pub fn require_concurrent_index_creation(tree: &[RootStmt]) -> Vec<RuleViolation> {
     let tables_created = tables_created_in_transaction(tree);
     let mut errs = vec![];

linter/src/violations.rs

@@ -79,6 +79,7 @@ pub struct RuleViolation {
 }
 
 impl RuleViolation {
+    #[must_use]
     pub fn new(
         kind: RuleViolationKind,
         node: &RawStmt,

parser/src/ast.rs

@@ -494,16 +494,16 @@ pub enum QualifiedName {
 }
 
 ///
-/// TypeName - specifies a type in definitions
+/// `TypeName` - specifies a type in definitions
 ///
-/// For TypeName structures generated internally, it is often easier to
-/// specify the type by OID than by name.  If "names" is NIL then the
-/// actual type OID is given by typeOid, otherwise typeOid is unused.
-/// Similarly, if "typmods" is NIL then the actual typmod is expected to
+/// For `TypeName` structures generated internally, it is often easier to
+/// specify the type by OID than by name.  If `names` is NIL then the
+/// actual type OID is given by `type_oid`, otherwise `type_oid` is unused.
+/// Similarly, if `typmods` is NIL then the actual typmod is expected to
 /// be prespecified in typemod, otherwise typemod is unused.
 ///
-/// If pct_type is true, then names is actually a field name and we look up
-/// the type of that field.  Otherwise (the normal case), names is a type
+/// If `pct_type` is true, then `names` is actually a field name and we look up
+/// the type of that field.  Otherwise (the normal case), `names` is a type
 /// name possibly qualified with schema and database name.
 ///
 #[derive(Debug, Deserialize, Serialize)]
@@ -734,7 +734,7 @@ pub enum RootStmt {
 }
 
 /// case for each node type found in Postgres' parsenodes.h
-/// https://github.com/lfittl/libpg_query/blob/6b1c3a582d38701593c5cadd260445737b9f7043/src/postgres/include/nodes/parsenodes.h
+/// <https://github.com/lfittl/libpg_query/blob/6b1c3a582d38701593c5cadd260445737b9f7043/src/postgres/include/nodes/parsenodes.h>
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, Deserialize, Serialize)]
 pub enum Stmt {

parser/src/lib.rs

@@ -1,3 +1,11 @@
+#[allow(clippy::module_name_repetitions)]
+#[allow(clippy::pub_enum_variant_names)]
+#[allow(clippy::struct_excessive_bools)]
 pub mod ast;
+#[allow(clippy::module_name_repetitions)]
 pub mod error;
+#[allow(clippy::module_name_repetitions)]
+#[allow(clippy::shadow_unrelated)]
+#[allow(clippy::doc_markdown)]
+#[allow(clippy::missing_errors_doc)]
 pub mod parse;

parser/src/parse.rs

@@ -12,7 +12,7 @@ fn c_ptr_to_string(str_ptr: *mut ::std::os::raw::c_char) -> Option<String> {
         unsafe { CStr::from_ptr(str_ptr) }
             .to_str()
             .ok()
-            .map(|s| s.to_owned())
+            .map(ToOwned::to_owned)
     }
 }