diff --git a/flake8_to_ruff/src/converter.rs b/flake8_to_ruff/src/converter.rs
index ef23c59b6d..39b9da20b2 100644
--- a/flake8_to_ruff/src/converter.rs
+++ b/flake8_to_ruff/src/converter.rs
@@ -18,7 +18,7 @@ pub fn convert(
     plugins: Option<Vec<Plugin>>,
 ) -> Result<Pyproject> {
     // Extract all referenced check code prefixes, to power plugin inference.
-    let mut referenced_codes: BTreeSet<CheckCodePrefix> = Default::default();
+    let mut referenced_codes: BTreeSet<CheckCodePrefix> = BTreeSet::default();
     for (key, value) in flake8 {
         if let Some(value) = value {
             match key.as_str() {
@@ -70,13 +70,13 @@ pub fn convert(
         .unwrap_or_default();
 
     // Parse each supported option.
-    let mut options: Options = Default::default();
-    let mut flake8_annotations: flake8_annotations::settings::Options = Default::default();
-    let mut flake8_bugbear: flake8_bugbear::settings::Options = Default::default();
-    let mut flake8_quotes: flake8_quotes::settings::Options = Default::default();
-    let mut flake8_tidy_imports: flake8_tidy_imports::settings::Options = Default::default();
-    let mut mccabe: mccabe::settings::Options = Default::default();
-    let mut pep8_naming: pep8_naming::settings::Options = Default::default();
+    let mut options = Options::default();
+    let mut flake8_annotations = flake8_annotations::settings::Options::default();
+    let mut flake8_bugbear = flake8_bugbear::settings::Options::default();
+    let mut flake8_quotes = flake8_quotes::settings::Options::default();
+    let mut flake8_tidy_imports = flake8_tidy_imports::settings::Options::default();
+    let mut mccabe = mccabe::settings::Options::default();
+    let mut pep8_naming = pep8_naming::settings::Options::default();
     for (key, value) in flake8 {
         if let Some(value) = value {
             match key.as_str() {
@@ -203,22 +203,22 @@ pub fn convert(
     // Deduplicate and sort.
     options.select = Some(Vec::from_iter(select));
     options.ignore = Some(Vec::from_iter(ignore));
-    if flake8_annotations != Default::default() {
+    if flake8_annotations != flake8_annotations::settings::Options::default() {
         options.flake8_annotations = Some(flake8_annotations);
     }
-    if flake8_bugbear != Default::default() {
+    if flake8_bugbear != flake8_bugbear::settings::Options::default() {
         options.flake8_bugbear = Some(flake8_bugbear);
     }
-    if flake8_quotes != Default::default() {
+    if flake8_quotes != flake8_quotes::settings::Options::default() {
         options.flake8_quotes = Some(flake8_quotes);
     }
-    if flake8_tidy_imports != Default::default() {
+    if flake8_tidy_imports != flake8_tidy_imports::settings::Options::default() {
         options.flake8_tidy_imports = Some(flake8_tidy_imports);
     }
-    if mccabe != Default::default() {
+    if mccabe != mccabe::settings::Options::default() {
         options.mccabe = Some(mccabe);
     }
-    if pep8_naming != Default::default() {
+    if pep8_naming != pep8_naming::settings::Options::default() {
         options.pep8_naming = Some(pep8_naming);
     }
 
diff --git a/ruff_dev/src/generate_check_code_prefix.rs b/ruff_dev/src/generate_check_code_prefix.rs
index b072e22641..5e937b15de 100644
--- a/ruff_dev/src/generate_check_code_prefix.rs
+++ b/ruff_dev/src/generate_check_code_prefix.rs
@@ -24,7 +24,7 @@ pub struct Cli {
 
 pub fn main(cli: &Cli) -> Result<()> {
     // Build up a map from prefix to matching CheckCodes.
-    let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = Default::default();
+    let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = BTreeMap::default();
     for check_code in CheckCode::iter() {
         let as_ref: String = check_code.as_ref().to_string();
         let prefix_len = as_ref
diff --git a/src/check_ast.rs b/src/check_ast.rs
index 44f8952747..302b467299 100644
--- a/src/check_ast.rs
+++ b/src/check_ast.rs
@@ -19,7 +19,8 @@ use crate::ast::helpers::{
 use crate::ast::operations::extract_all_names;
 use crate::ast::relocate::relocate_expr;
 use crate::ast::types::{
-    Binding, BindingContext, BindingKind, ClassScope, ImportKind, Range, Scope, ScopeKind,
+    Binding, BindingContext, BindingKind, ClassScope, FunctionScope, ImportKind, Range, Scope,
+    ScopeKind,
 };
 use crate::ast::visitor::{walk_excepthandler, Visitor};
 use crate::ast::{helpers, operations, visitor};
@@ -95,35 +96,35 @@ impl<'a> Checker<'a> {
             autofix,
             path,
             locator,
-            checks: Default::default(),
-            definitions: Default::default(),
-            deletions: Default::default(),
-            from_imports: Default::default(),
-            import_aliases: Default::default(),
-            parents: Default::default(),
-            parent_stack: Default::default(),
-            scopes: Default::default(),
-            scope_stack: Default::default(),
-            dead_scopes: Default::default(),
-            deferred_string_annotations: Default::default(),
-            deferred_annotations: Default::default(),
-            deferred_functions: Default::default(),
-            deferred_lambdas: Default::default(),
-            deferred_assignments: Default::default(),
+            checks: vec![],
+            definitions: vec![],
+            deletions: FxHashSet::default(),
+            from_imports: FxHashMap::default(),
+            import_aliases: FxHashMap::default(),
+            parents: vec![],
+            parent_stack: vec![],
+            scopes: vec![],
+            scope_stack: vec![],
+            dead_scopes: vec![],
+            deferred_string_annotations: vec![],
+            deferred_annotations: vec![],
+            deferred_functions: vec![],
+            deferred_lambdas: vec![],
+            deferred_assignments: vec![],
             // Internal, derivative state.
             visible_scope: VisibleScope {
                 modifier: Modifier::Module,
                 visibility: module_visibility(path),
             },
-            in_f_string: Default::default(),
-            in_annotation: Default::default(),
-            in_deferred_string_annotation: Default::default(),
-            in_literal: Default::default(),
-            in_subscript: Default::default(),
-            seen_import_boundary: Default::default(),
+            in_f_string: None,
+            in_annotation: false,
+            in_deferred_string_annotation: false,
+            in_literal: false,
+            in_subscript: false,
+            seen_import_boundary: false,
             futures_allowed: true,
-            annotations_future_enabled: Default::default(),
-            except_handlers: Default::default(),
+            annotations_future_enabled: false,
+            except_handlers: vec![],
         }
     }
 
@@ -2161,7 +2162,7 @@ impl<'a> Checker<'a> {
                 builtin,
                 Binding {
                     kind: BindingKind::Builtin,
-                    range: Default::default(),
+                    range: Range::default(),
                     used: None,
                 },
             );
@@ -2171,7 +2172,7 @@ impl<'a> Checker<'a> {
                 builtin,
                 Binding {
                     kind: BindingKind::Builtin,
-                    range: Default::default(),
+                    range: Range::default(),
                     used: None,
                 },
             );
@@ -2523,7 +2524,7 @@ impl<'a> Checker<'a> {
             self.parent_stack = parents;
             self.scope_stack = scopes;
             self.visible_scope = visibility;
-            self.push_scope(Scope::new(ScopeKind::Function(Default::default())));
+            self.push_scope(Scope::new(ScopeKind::Function(FunctionScope::default())));
 
             match &stmt.node {
                 StmtKind::FunctionDef { body, args, .. }
diff --git a/src/check_lines.rs b/src/check_lines.rs
index e3f3960a2a..906bc856da 100644
--- a/src/check_lines.rs
+++ b/src/check_lines.rs
@@ -264,7 +264,7 @@ mod tests {
     #[test]
     fn e501_non_ascii_char() {
         let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
-        let noqa_line_for: IntMap<usize, usize> = Default::default();
+        let noqa_line_for: IntMap<usize, usize> = IntMap::default();
         let check_with_max_line_length = |line_length: usize| {
             let mut checks: Vec<Check> = vec![];
             check_lines(
diff --git a/src/check_tokens.rs b/src/check_tokens.rs
index 783d4bc808..f6b61e3ed8 100644
--- a/src/check_tokens.rs
+++ b/src/check_tokens.rs
@@ -25,7 +25,7 @@ pub fn check_tokens(
         || settings.enabled.contains(&CheckCode::Q003);
     let enforce_invalid_escape_sequence = settings.enabled.contains(&CheckCode::W605);
 
-    let mut state_machine: StateMachine = Default::default();
+    let mut state_machine = StateMachine::default();
     for &(start, ref tok, end) in tokens.iter().flatten() {
         let is_docstring = if enforce_ambiguous_unicode_character || enforce_quotes {
             state_machine.consume(tok)
diff --git a/src/code_gen.rs b/src/code_gen.rs
index 0c113cc318..a397edac24 100644
--- a/src/code_gen.rs
+++ b/src/code_gen.rs
@@ -950,7 +950,7 @@ impl SourceGenerator {
         conversion: usize,
         spec: Option<&Expr<U>>,
     ) -> fmt::Result {
-        let mut generator: SourceGenerator = Default::default();
+        let mut generator = SourceGenerator::default();
         generator.unparse_expr(val, precedence::TEST + 1)?;
         let brace = if generator.buffer.starts_with("{".as_bytes()) {
             // put a space to avoid escaping the bracket
@@ -1007,7 +1007,7 @@ impl SourceGenerator {
             self.unparse_fstring_body(values, is_spec)?;
         } else {
             self.p("f")?;
-            let mut generator: SourceGenerator = Default::default();
+            let mut generator = SourceGenerator::default();
             generator.unparse_fstring_body(values, is_spec)?;
             let body = std::str::from_utf8(&generator.buffer).unwrap();
             self.p(&format!("{}", str::repr(body)))?;
diff --git a/src/directives.rs b/src/directives.rs
index 3e164f2619..b535c3b1f7 100644
--- a/src/directives.rs
+++ b/src/directives.rs
@@ -44,12 +44,12 @@ pub fn extract_directives(
         noqa_line_for: if flags.contains(Flags::NOQA) {
             extract_noqa_line_for(lxr)
         } else {
-            Default::default()
+            IntMap::default()
         },
         isort_exclusions: if flags.contains(Flags::ISORT) {
             extract_isort_exclusions(lxr, locator)
         } else {
-            Default::default()
+            IntSet::default()
         },
     }
 }
@@ -122,7 +122,7 @@ mod tests {
 
     #[test]
     fn extraction() -> Result<()> {
-        let empty: IntMap<usize, usize> = Default::default();
+        let empty: IntMap<usize, usize> = IntMap::default();
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = 1
diff --git a/src/flake8_annotations/plugins.rs b/src/flake8_annotations/plugins.rs
index bfe777a049..4fae81850e 100644
--- a/src/flake8_annotations/plugins.rs
+++ b/src/flake8_annotations/plugins.rs
@@ -34,7 +34,7 @@ where
 }
 
 fn is_none_returning(body: &[Stmt]) -> bool {
-    let mut visitor: ReturnStatementVisitor = Default::default();
+    let mut visitor = ReturnStatementVisitor::default();
     for stmt in body {
         visitor.visit_stmt(stmt);
     }
diff --git a/src/flake8_bugbear/plugins/assert_false.rs b/src/flake8_bugbear/plugins/assert_false.rs
index 4daa507db9..c6406f2a71 100644
--- a/src/flake8_bugbear/plugins/assert_false.rs
+++ b/src/flake8_bugbear/plugins/assert_false.rs
@@ -1,4 +1,4 @@
-use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Stmt, StmtKind};
+use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
@@ -8,16 +8,16 @@ use crate::code_gen::SourceGenerator;
 
 fn assertion_error(msg: Option<&Expr>) -> Stmt {
     Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::Raise {
             exc: Some(Box::new(Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 ExprKind::Call {
                     func: Box::new(Expr::new(
-                        Default::default(),
-                        Default::default(),
+                        Location::default(),
+                        Location::default(),
                         ExprKind::Name {
                             id: "AssertionError".to_string(),
                             ctx: ExprContext::Load,
diff --git a/src/flake8_bugbear/plugins/duplicate_exceptions.rs b/src/flake8_bugbear/plugins/duplicate_exceptions.rs
index ba71042e50..37747295bc 100644
--- a/src/flake8_bugbear/plugins/duplicate_exceptions.rs
+++ b/src/flake8_bugbear/plugins/duplicate_exceptions.rs
@@ -1,7 +1,9 @@
 use std::collections::BTreeSet;
 
 use itertools::Itertools;
-use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind, Stmt};
+use rustpython_ast::{
+    Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind, Location, Stmt,
+};
 
 use crate::ast::helpers;
 use crate::ast::types::Range;
@@ -12,8 +14,8 @@ use crate::code_gen::SourceGenerator;
 
 fn type_pattern(elts: Vec<&Expr>) -> Expr {
     Expr::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         ExprKind::Tuple {
             elts: elts.into_iter().cloned().collect(),
             ctx: ExprContext::Load,
@@ -26,9 +28,9 @@ fn duplicate_handler_exceptions<'a>(
     expr: &'a Expr,
     elts: &'a [Expr],
 ) -> BTreeSet<Vec<&'a str>> {
-    let mut seen: BTreeSet<Vec<&str>> = Default::default();
-    let mut duplicates: BTreeSet<Vec<&str>> = Default::default();
-    let mut unique_elts: Vec<&Expr> = Default::default();
+    let mut seen: BTreeSet<Vec<&str>> = BTreeSet::default();
+    let mut duplicates: BTreeSet<Vec<&str>> = BTreeSet::default();
+    let mut unique_elts: Vec<&Expr> = Vec::default();
     for type_ in elts {
         let call_path = helpers::collect_call_paths(type_);
         if !call_path.is_empty() {
@@ -75,8 +77,8 @@ fn duplicate_handler_exceptions<'a>(
 }
 
 pub fn duplicate_exceptions(checker: &mut Checker, stmt: &Stmt, handlers: &[Excepthandler]) {
-    let mut seen: BTreeSet<Vec<&str>> = Default::default();
-    let mut duplicates: BTreeSet<Vec<&str>> = Default::default();
+    let mut seen: BTreeSet<Vec<&str>> = BTreeSet::default();
+    let mut duplicates: BTreeSet<Vec<&str>> = BTreeSet::default();
     for handler in handlers {
         match &handler.node {
             ExcepthandlerKind::ExceptHandler { type_, .. } => {
diff --git a/src/flake8_bugbear/plugins/getattr_with_constant.rs b/src/flake8_bugbear/plugins/getattr_with_constant.rs
index dd4ede21b0..d5754ddd0b 100644
--- a/src/flake8_bugbear/plugins/getattr_with_constant.rs
+++ b/src/flake8_bugbear/plugins/getattr_with_constant.rs
@@ -1,4 +1,4 @@
-use rustpython_ast::{Constant, Expr, ExprContext, ExprKind};
+use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
@@ -10,8 +10,8 @@ use crate::python::keyword::KWLIST;
 
 fn attribute(value: &Expr, attr: &str) -> Expr {
     Expr::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         ExprKind::Attribute {
             value: Box::new(value.clone()),
             attr: attr.to_string(),
diff --git a/src/flake8_bugbear/plugins/setattr_with_constant.rs b/src/flake8_bugbear/plugins/setattr_with_constant.rs
index 894a3ca649..c3f1292b51 100644
--- a/src/flake8_bugbear/plugins/setattr_with_constant.rs
+++ b/src/flake8_bugbear/plugins/setattr_with_constant.rs
@@ -1,4 +1,4 @@
-use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Stmt, StmtKind};
+use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
@@ -10,12 +10,12 @@ use crate::python::keyword::KWLIST;
 
 fn assignment(obj: &Expr, name: &str, value: &Expr) -> Option<String> {
     let stmt = Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::Assign {
             targets: vec![Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 ExprKind::Attribute {
                     value: Box::new(obj.clone()),
                     attr: name.to_string(),
diff --git a/src/flake8_bugbear/plugins/unused_loop_control_variable.rs b/src/flake8_bugbear/plugins/unused_loop_control_variable.rs
index 5bf326a250..759c1dc40f 100644
--- a/src/flake8_bugbear/plugins/unused_loop_control_variable.rs
+++ b/src/flake8_bugbear/plugins/unused_loop_control_variable.rs
@@ -17,7 +17,7 @@ struct NameFinder<'a> {
 impl NameFinder<'_> {
     fn new() -> Self {
         NameFinder {
-            names: Default::default(),
+            names: FxHashMap::default(),
         }
     }
 }
diff --git a/src/flake8_comprehensions/fixes.rs b/src/flake8_comprehensions/fixes.rs
index 3dd9c7cb3d..fdf199a18f 100644
--- a/src/flake8_comprehensions/fixes.rs
+++ b/src/flake8_comprehensions/fixes.rs
@@ -1,9 +1,9 @@
 use anyhow::Result;
 use libcst_native::{
-    Arg, AssignEqual, Call, Codegen, Dict, DictComp, DictElement, Element, Expr, Expression,
-    LeftCurlyBrace, LeftParen, LeftSquareBracket, List, ListComp, Name, ParenthesizableWhitespace,
-    RightCurlyBrace, RightParen, RightSquareBracket, Set, SetComp, SimpleString, SimpleWhitespace,
-    Tuple,
+    Arg, AssignEqual, Call, Codegen, CodegenState, Dict, DictComp, DictElement, Element, Expr,
+    Expression, LeftCurlyBrace, LeftParen, LeftSquareBracket, List, ListComp, Name,
+    ParenthesizableWhitespace, RightCurlyBrace, RightParen, RightSquareBracket, Set, SetComp,
+    SimpleString, SimpleWhitespace, Tuple,
 };
 
 use crate::ast::types::Range;
@@ -60,7 +60,7 @@ pub fn fix_unnecessary_generator_list(
         rpar: generator_exp.rpar.clone(),
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -103,7 +103,7 @@ pub fn fix_unnecessary_generator_set(
         rpar: generator_exp.rpar.clone(),
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -163,13 +163,13 @@ pub fn fix_unnecessary_generator_dict(
         rbrace: RightCurlyBrace {
             whitespace_before: arg.whitespace_after_arg.clone(),
         },
-        lpar: Default::default(),
-        rpar: Default::default(),
-        whitespace_before_colon: Default::default(),
+        lpar: vec![],
+        rpar: vec![],
+        whitespace_before_colon: ParenthesizableWhitespace::default(),
         whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(SimpleWhitespace(" ")),
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -211,7 +211,7 @@ pub fn fix_unnecessary_list_comprehension_set(
         rpar: list_comp.rpar.clone(),
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -269,7 +269,7 @@ pub fn fix_unnecessary_list_comprehension_dict(
         rpar: list_comp.rpar.clone(),
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -312,12 +312,12 @@ pub fn fix_unnecessary_literal_set(
             rbrace: RightCurlyBrace {
                 whitespace_before: arg.whitespace_after_arg.clone(),
             },
-            lpar: Default::default(),
-            rpar: Default::default(),
+            lpar: vec![],
+            rpar: vec![],
         }));
     }
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -363,7 +363,7 @@ pub fn fix_unnecessary_literal_dict(
                             key: key.clone(),
                             value: value.clone(),
                             comma: comma.clone(),
-                            whitespace_before_colon: Default::default(),
+                            whitespace_before_colon: ParenthesizableWhitespace::default(),
                             whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(
                                 SimpleWhitespace(" "),
                             ),
@@ -385,11 +385,11 @@ pub fn fix_unnecessary_literal_dict(
         rbrace: RightCurlyBrace {
             whitespace_before: arg.whitespace_after_arg.clone(),
         },
-        lpar: Default::default(),
-        rpar: Default::default(),
+        lpar: vec![],
+        rpar: vec![],
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -422,28 +422,28 @@ pub fn fix_unnecessary_collection_call(
     match name.value {
         "tuple" => {
             body.value = Expression::Tuple(Box::new(Tuple {
-                elements: Default::default(),
-                lpar: vec![Default::default()],
-                rpar: vec![Default::default()],
+                elements: vec![],
+                lpar: vec![LeftParen::default()],
+                rpar: vec![RightParen::default()],
             }));
         }
         "list" => {
             body.value = Expression::List(Box::new(List {
-                elements: Default::default(),
-                lbracket: Default::default(),
-                rbracket: Default::default(),
-                lpar: Default::default(),
-                rpar: Default::default(),
+                elements: vec![],
+                lbracket: LeftSquareBracket::default(),
+                rbracket: RightSquareBracket::default(),
+                lpar: vec![],
+                rpar: vec![],
             }));
         }
         "dict" => {
             if call.args.is_empty() {
                 body.value = Expression::Dict(Box::new(Dict {
-                    elements: Default::default(),
-                    lbrace: Default::default(),
-                    rbrace: Default::default(),
-                    lpar: Default::default(),
-                    rpar: Default::default(),
+                    elements: vec![],
+                    lbrace: LeftCurlyBrace::default(),
+                    rbrace: RightCurlyBrace::default(),
+                    lpar: vec![],
+                    rpar: vec![],
                 }));
             } else {
                 // Quote each argument.
@@ -465,12 +465,12 @@ pub fn fix_unnecessary_collection_call(
                     .map(|(i, arg)| DictElement::Simple {
                         key: Expression::SimpleString(Box::new(SimpleString {
                             value: &arena[i],
-                            lpar: Default::default(),
-                            rpar: Default::default(),
+                            lpar: vec![],
+                            rpar: vec![],
                         })),
                         value: arg.value.clone(),
                         comma: arg.comma.clone(),
-                        whitespace_before_colon: Default::default(),
+                        whitespace_before_colon: ParenthesizableWhitespace::default(),
                         whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(
                             SimpleWhitespace(" "),
                         ),
@@ -490,8 +490,8 @@ pub fn fix_unnecessary_collection_call(
                             .whitespace_after_arg
                             .clone(),
                     },
-                    lpar: Default::default(),
-                    rpar: Default::default(),
+                    lpar: vec![],
+                    rpar: vec![],
                 }));
             }
         }
@@ -502,7 +502,7 @@ pub fn fix_unnecessary_collection_call(
         }
     };
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -558,7 +558,7 @@ pub fn fix_unnecessary_literal_within_tuple_call(
         }],
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -612,11 +612,11 @@ pub fn fix_unnecessary_literal_within_list_call(
         rbracket: RightSquareBracket {
             whitespace_before: whitespace_before.clone(),
         },
-        lpar: Default::default(),
-        rpar: Default::default(),
+        lpar: vec![],
+        rpar: vec![],
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -640,7 +640,7 @@ pub fn fix_unnecessary_list_call(
 
     body.value = arg.value.clone();
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -695,22 +695,22 @@ pub fn fix_unnecessary_call_around_sorted(
                 args.push(Arg {
                     value: Expression::Name(Box::new(Name {
                         value: "True",
-                        lpar: Default::default(),
-                        rpar: Default::default(),
+                        lpar: vec![],
+                        rpar: vec![],
                     })),
                     keyword: Some(Name {
                         value: "reverse",
-                        lpar: Default::default(),
-                        rpar: Default::default(),
+                        lpar: vec![],
+                        rpar: vec![],
                     }),
                     equal: Some(AssignEqual {
-                        whitespace_before: Default::default(),
-                        whitespace_after: Default::default(),
+                        whitespace_before: ParenthesizableWhitespace::default(),
+                        whitespace_after: ParenthesizableWhitespace::default(),
                     }),
-                    comma: Default::default(),
-                    star: Default::default(),
-                    whitespace_after_star: Default::default(),
-                    whitespace_after_arg: Default::default(),
+                    comma: None,
+                    star: "",
+                    whitespace_after_star: ParenthesizableWhitespace::default(),
+                    whitespace_after_arg: ParenthesizableWhitespace::default(),
                 });
                 args
             };
@@ -726,7 +726,7 @@ pub fn fix_unnecessary_call_around_sorted(
         }
     }
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
@@ -750,44 +750,44 @@ pub fn fix_unnecessary_comprehension(
             body.value = Expression::Call(Box::new(Call {
                 func: Box::new(Expression::Name(Box::new(Name {
                     value: "list",
-                    lpar: Default::default(),
-                    rpar: Default::default(),
+                    lpar: vec![],
+                    rpar: vec![],
                 }))),
                 args: vec![Arg {
                     value: inner.for_in.iter.clone(),
-                    keyword: Default::default(),
-                    equal: Default::default(),
-                    comma: Default::default(),
-                    star: Default::default(),
-                    whitespace_after_star: Default::default(),
-                    whitespace_after_arg: Default::default(),
+                    keyword: None,
+                    equal: None,
+                    comma: None,
+                    star: "",
+                    whitespace_after_star: ParenthesizableWhitespace::default(),
+                    whitespace_after_arg: ParenthesizableWhitespace::default(),
                 }],
-                lpar: Default::default(),
-                rpar: Default::default(),
-                whitespace_after_func: Default::default(),
-                whitespace_before_args: Default::default(),
+                lpar: vec![],
+                rpar: vec![],
+                whitespace_after_func: ParenthesizableWhitespace::default(),
+                whitespace_before_args: ParenthesizableWhitespace::default(),
             }))
         }
         Expression::SetComp(inner) => {
             body.value = Expression::Call(Box::new(Call {
                 func: Box::new(Expression::Name(Box::new(Name {
                     value: "set",
-                    lpar: Default::default(),
-                    rpar: Default::default(),
+                    lpar: vec![],
+                    rpar: vec![],
                 }))),
                 args: vec![Arg {
                     value: inner.for_in.iter.clone(),
-                    keyword: Default::default(),
-                    equal: Default::default(),
-                    comma: Default::default(),
-                    star: Default::default(),
-                    whitespace_after_star: Default::default(),
-                    whitespace_after_arg: Default::default(),
+                    keyword: None,
+                    equal: None,
+                    comma: None,
+                    star: "",
+                    whitespace_after_star: ParenthesizableWhitespace::default(),
+                    whitespace_after_arg: ParenthesizableWhitespace::default(),
                 }],
-                lpar: Default::default(),
-                rpar: Default::default(),
-                whitespace_after_func: Default::default(),
-                whitespace_before_args: Default::default(),
+                lpar: vec![],
+                rpar: vec![],
+                whitespace_after_func: ParenthesizableWhitespace::default(),
+                whitespace_before_args: ParenthesizableWhitespace::default(),
             }))
         }
         _ => {
@@ -797,7 +797,7 @@ pub fn fix_unnecessary_comprehension(
         }
     }
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
diff --git a/src/isort/mod.rs b/src/isort/mod.rs
index 7b543560c1..facbdf7d83 100644
--- a/src/isort/mod.rs
+++ b/src/isort/mod.rs
@@ -146,7 +146,7 @@ fn annotate_imports<'a>(
 }
 
 fn normalize_imports(imports: Vec<AnnotatedImport>) -> ImportBlock {
-    let mut block: ImportBlock = Default::default();
+    let mut block = ImportBlock::default();
     for import in imports {
         match import {
             AnnotatedImport::Import {
@@ -274,7 +274,7 @@ fn categorize_imports<'a>(
     known_third_party: &BTreeSet<String>,
     extra_standard_library: &BTreeSet<String>,
 ) -> BTreeMap<ImportType, ImportBlock<'a>> {
-    let mut block_by_type: BTreeMap<ImportType, ImportBlock> = Default::default();
+    let mut block_by_type: BTreeMap<ImportType, ImportBlock> = BTreeMap::default();
     // Categorize `StmtKind::Import`.
     for (alias, comments) in block.import {
         let import_type = categorize(
@@ -327,7 +327,7 @@ fn categorize_imports<'a>(
 }
 
 fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
-    let mut ordered: OrderedImportBlock = Default::default();
+    let mut ordered = OrderedImportBlock::default();
 
     // Sort `StmtKind::Import`.
     ordered.import.extend(
@@ -354,12 +354,12 @@ fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
                             (
                                 CommentSet {
                                     atop: comments.atop,
-                                    inline: Default::default(),
+                                    inline: vec![],
                                 },
                                 FxHashMap::from_iter([(
                                     alias,
                                     CommentSet {
-                                        atop: Default::default(),
+                                        atop: vec![],
                                         inline: comments.inline,
                                     },
                                 )]),
diff --git a/src/linter.rs b/src/linter.rs
index d0a7cdf99e..2cda8ad62b 100644
--- a/src/linter.rs
+++ b/src/linter.rs
@@ -295,7 +295,7 @@ pub fn autoformat_path(path: &Path) -> Result<()> {
 
     // Generate the AST.
     let python_ast = parse_program_tokens(tokens, "<filename>")?;
-    let mut generator: SourceGenerator = Default::default();
+    let mut generator = SourceGenerator::default();
     generator.unparse_suite(&python_ast)?;
     write(path, generator.generate()?)?;
 
diff --git a/src/main.rs b/src/main.rs
index 61c3b6eb68..c2e038694b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -25,6 +25,7 @@ use log::{debug, error};
 use notify::{raw_watcher, RecursiveMode, Watcher};
 #[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
+use rustpython_ast::Location;
 use walkdir::DirEntry;
 
 /// Shim that calls par_iter except for wasm because there's no wasm support in
@@ -113,8 +114,8 @@ fn run_once(
                         vec![Message {
                             kind: CheckKind::IOError(message),
                             fixed: false,
-                            location: Default::default(),
-                            end_location: Default::default(),
+                            location: Location::default(),
+                            end_location: Location::default(),
                             filename: path.to_string_lossy().to_string(),
                             source: None,
                         }]
diff --git a/src/message.rs b/src/message.rs
index 698a299390..c5ff24f158 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -91,7 +91,7 @@ impl fmt::Display for Message {
                     }],
                     opt: FormatOptions {
                         color: true,
-                        ..Default::default()
+                        ..FormatOptions::default()
                     },
                 };
                 // `split_once(' ')` strips "error: " from `message`.
diff --git a/src/noqa.rs b/src/noqa.rs
index 9ea34f8319..e498b5b6bf 100644
--- a/src/noqa.rs
+++ b/src/noqa.rs
@@ -121,6 +121,7 @@ fn add_noqa_inner(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
+    use nohash_hasher::IntMap;
     use rustpython_parser::ast::Location;
 
     use crate::ast::types::Range;
@@ -145,7 +146,7 @@ mod tests {
     fn modification() -> Result<()> {
         let checks = vec![];
         let contents = "x = 1";
-        let noqa_line_for = Default::default();
+        let noqa_line_for = IntMap::default();
         let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
         assert_eq!(count, 0);
         assert_eq!(output.trim(), contents.trim());
@@ -158,7 +159,7 @@ mod tests {
             },
         )];
         let contents = "x = 1";
-        let noqa_line_for = Default::default();
+        let noqa_line_for = IntMap::default();
         let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
         assert_eq!(count, 1);
         assert_eq!(output.trim(), "x = 1  # noqa: F841".trim());
@@ -180,7 +181,7 @@ mod tests {
             ),
         ];
         let contents = "x = 1  # noqa: E741";
-        let noqa_line_for = Default::default();
+        let noqa_line_for = IntMap::default();
         let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
         assert_eq!(count, 1);
         assert_eq!(output.trim(), "x = 1  # noqa: E741, F841".trim());
@@ -202,7 +203,7 @@ mod tests {
             ),
         ];
         let contents = "x = 1  # noqa";
-        let noqa_line_for = Default::default();
+        let noqa_line_for = IntMap::default();
         let (count, output) = add_noqa_inner(&checks, contents, &noqa_line_for)?;
         assert_eq!(count, 1);
         assert_eq!(output.trim(), "x = 1  # noqa: E741, F841".trim());
diff --git a/src/pycodestyle/plugins.rs b/src/pycodestyle/plugins.rs
index 052bb1d1ac..df4a361ca5 100644
--- a/src/pycodestyle/plugins.rs
+++ b/src/pycodestyle/plugins.rs
@@ -15,8 +15,8 @@ use crate::code_gen::SourceGenerator;
 
 fn compare(left: &Expr, ops: &[Cmpop], comparators: &[Expr]) -> Option<String> {
     let cmp = Expr::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         ExprKind::Compare {
             left: Box::new(left.clone()),
             ops: ops.to_vec(),
@@ -268,15 +268,15 @@ pub fn not_tests(
 
 fn function(name: &str, args: &Arguments, body: &Expr) -> Result<String> {
     let body = Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::Return {
             value: Some(Box::new(body.clone())),
         },
     );
     let func = Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::FunctionDef {
             name: name.to_string(),
             args: Box::new(args.clone()),
diff --git a/src/pydocstyle/plugins.rs b/src/pydocstyle/plugins.rs
index 98c14f0b83..52cfec4b45 100644
--- a/src/pydocstyle/plugins.rs
+++ b/src/pydocstyle/plugins.rs
@@ -1326,7 +1326,7 @@ fn missing_args(checker: &mut Checker, definition: &Definition, docstrings_args:
             }
 
             // Look for arguments that weren't included in the docstring.
-            let mut missing_args: BTreeSet<&str> = Default::default();
+            let mut missing_args: BTreeSet<&str> = BTreeSet::default();
             for arg in all_arguments {
                 let arg_name = arg.node.arg.as_str();
                 if arg_name.starts_with('_') {
diff --git a/src/pyflakes/fixes.rs b/src/pyflakes/fixes.rs
index f0a550c169..8fcf12f317 100644
--- a/src/pyflakes/fixes.rs
+++ b/src/pyflakes/fixes.rs
@@ -1,7 +1,7 @@
 use anyhow::Result;
 use libcst_native::{
-    Codegen, CompOp, Comparison, ComparisonTarget, Expr, Expression, ImportNames, NameOrAttribute,
-    SmallStatement, Statement,
+    Codegen, CodegenState, CompOp, Comparison, ComparisonTarget, Expr, Expression, ImportNames,
+    NameOrAttribute, SmallStatement, Statement,
 };
 use rustpython_ast::Stmt;
 
@@ -58,7 +58,7 @@ pub fn remove_unused_imports(
     if aliases.is_empty() {
         helpers::remove_stmt(stmt, parent, deleted)
     } else {
-        let mut state = Default::default();
+        let mut state = CodegenState::default();
         tree.codegen(&mut state);
 
         Ok(Fix::replacement(
@@ -131,7 +131,7 @@ pub fn remove_unused_import_froms(
     if aliases.is_empty() {
         helpers::remove_stmt(stmt, parent, deleted)
     } else {
-        let mut state = Default::default();
+        let mut state = CodegenState::default();
         tree.codegen(&mut state);
 
         Ok(Fix::replacement(
@@ -195,7 +195,7 @@ pub fn fix_invalid_literal_comparison(locator: &SourceCodeLocator, location: Ran
         rpar: cmp.rpar.clone(),
     }));
 
-    let mut state = Default::default();
+    let mut state = CodegenState::default();
     tree.codegen(&mut state);
 
     Ok(Fix::replacement(
diff --git a/src/pyupgrade/fixes.rs b/src/pyupgrade/fixes.rs
index f6701d5f6c..b50107699a 100644
--- a/src/pyupgrade/fixes.rs
+++ b/src/pyupgrade/fixes.rs
@@ -1,5 +1,8 @@
 use anyhow::Result;
-use libcst_native::{Codegen, Expression, ImportNames, SmallStatement, Statement};
+use libcst_native::{
+    Codegen, CodegenState, Expression, ImportNames, ParenthesizableWhitespace, SmallStatement,
+    Statement,
+};
 use rustpython_ast::{Expr, Keyword, Location, Stmt};
 use rustpython_parser::lexer;
 use rustpython_parser::lexer::Tok;
@@ -117,10 +120,10 @@ pub fn remove_super_arguments(locator: &SourceCodeLocator, expr: &Expr) -> Optio
         if let Some(SmallStatement::Expr(body)) = body.body.first_mut() {
             if let Expression::Call(body) = &mut body.value {
                 body.args = vec![];
-                body.whitespace_before_args = Default::default();
-                body.whitespace_after_func = Default::default();
+                body.whitespace_before_args = ParenthesizableWhitespace::default();
+                body.whitespace_after_func = ParenthesizableWhitespace::default();
 
-                let mut state = Default::default();
+                let mut state = CodegenState::default();
                 tree.codegen(&mut state);
 
                 return Some(Fix::replacement(
@@ -181,7 +184,7 @@ pub fn remove_unnecessary_future_import(
     if aliases.is_empty() {
         autofix::helpers::remove_stmt(stmt, parent, deleted)
     } else {
-        let mut state = Default::default();
+        let mut state = CodegenState::default();
         tree.codegen(&mut state);
 
         Ok(Fix::replacement(
diff --git a/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs b/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs
index 226f09a841..b4459a5b3e 100644
--- a/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs
+++ b/src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs
@@ -1,6 +1,6 @@
 use anyhow::{bail, Result};
 use log::error;
-use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Keyword, Stmt, StmtKind};
+use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Keyword, Location, Stmt, StmtKind};
 
 use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
@@ -48,24 +48,29 @@ fn create_property_assignment_stmt(
     value: Option<&ExprKind>,
 ) -> Stmt {
     Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::AnnAssign {
             target: Box::new(Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 ExprKind::Name {
                     id: property.to_string(),
                     ctx: ExprContext::Load,
                 },
             )),
             annotation: Box::new(Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 annotation.clone(),
             )),
-            value: value
-                .map(|v| Box::new(Expr::new(Default::default(), Default::default(), v.clone()))),
+            value: value.map(|v| {
+                Box::new(Expr::new(
+                    Location::default(),
+                    Location::default(),
+                    v.clone(),
+                ))
+            }),
             simple: 1,
         },
     )
@@ -144,13 +149,13 @@ fn create_properties_from_args(args: &[Expr], defaults: &[Expr]) -> Result<Vec<S
 /// keywords.
 fn create_class_def_stmt(typename: &str, body: Vec<Stmt>, base_class: &ExprKind) -> Stmt {
     Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::ClassDef {
             name: typename.to_string(),
             bases: vec![Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 base_class.clone(),
             )],
             keywords: vec![],
diff --git a/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs b/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs
index 42e39b1016..c1de08e3ed 100644
--- a/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs
+++ b/src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs
@@ -1,6 +1,8 @@
 use anyhow::{bail, Result};
 use log::error;
-use rustpython_ast::{Constant, Expr, ExprContext, ExprKind, Keyword, KeywordData, Stmt, StmtKind};
+use rustpython_ast::{
+    Constant, Expr, ExprContext, ExprKind, Keyword, KeywordData, Location, Stmt, StmtKind,
+};
 
 use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
@@ -45,20 +47,20 @@ fn match_typed_dict_assign<'a>(
 /// definition.
 fn create_property_assignment_stmt(property: &str, annotation: &ExprKind) -> Stmt {
     Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::AnnAssign {
             target: Box::new(Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 ExprKind::Name {
                     id: property.to_string(),
                     ctx: ExprContext::Load,
                 },
             )),
             annotation: Box::new(Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 annotation.clone(),
             )),
             value: None,
@@ -69,7 +71,7 @@ fn create_property_assignment_stmt(property: &str, annotation: &ExprKind) -> Stm
 
 /// Generate a `StmtKind::Pass` statement.
 fn create_pass_stmt() -> Stmt {
-    Stmt::new(Default::default(), Default::default(), StmtKind::Pass)
+    Stmt::new(Location::default(), Location::default(), StmtKind::Pass)
 }
 
 /// Generate a `StmtKind:ClassDef` statement based on the provided body,
@@ -82,20 +84,20 @@ fn create_class_def_stmt(
 ) -> Stmt {
     let keywords = match total_keyword {
         Some(keyword) => vec![Keyword::new(
-            Default::default(),
-            Default::default(),
+            Location::default(),
+            Location::default(),
             keyword,
         )],
         None => vec![],
     };
     Stmt::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         StmtKind::ClassDef {
             name: class_name.to_string(),
             bases: vec![Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 base_class.clone(),
             )],
             keywords,
diff --git a/src/pyupgrade/plugins/use_pep604_annotation.rs b/src/pyupgrade/plugins/use_pep604_annotation.rs
index f2c5a04853..0e367a9564 100644
--- a/src/pyupgrade/plugins/use_pep604_annotation.rs
+++ b/src/pyupgrade/plugins/use_pep604_annotation.rs
@@ -1,4 +1,4 @@
-use rustpython_ast::{Constant, Expr, ExprKind, Operator};
+use rustpython_ast::{Constant, Expr, ExprKind, Location, Operator};
 
 use crate::ast::helpers::{collect_call_paths, dealias_call_path};
 use crate::ast::types::Range;
@@ -9,14 +9,14 @@ use crate::code_gen::SourceGenerator;
 
 fn optional(expr: &Expr) -> Expr {
     Expr::new(
-        Default::default(),
-        Default::default(),
+        Location::default(),
+        Location::default(),
         ExprKind::BinOp {
             left: Box::new(expr.clone()),
             op: Operator::BitOr,
             right: Box::new(Expr::new(
-                Default::default(),
-                Default::default(),
+                Location::default(),
+                Location::default(),
                 ExprKind::Constant {
                     value: Constant::None,
                     kind: None,
@@ -31,8 +31,8 @@ fn union(elts: &[Expr]) -> Expr {
         elts[0].clone()
     } else {
         Expr::new(
-            Default::default(),
-            Default::default(),
+            Location::default(),
+            Location::default(),
             ExprKind::BinOp {
                 left: Box::new(union(&elts[..elts.len() - 1])),
                 op: Operator::BitOr,
diff --git a/src/settings/mod.rs b/src/settings/mod.rs
index 8f131d1ef0..5d9f436097 100644
--- a/src/settings/mod.rs
+++ b/src/settings/mod.rs
@@ -85,20 +85,20 @@ impl Settings {
             dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$").unwrap(),
             enabled: FxHashSet::from_iter([check_code.clone()]),
             fixable: FxHashSet::from_iter([check_code]),
-            exclude: Default::default(),
-            extend_exclude: Default::default(),
+            exclude: vec![],
+            extend_exclude: vec![],
             line_length: 88,
-            per_file_ignores: Default::default(),
+            per_file_ignores: vec![],
             src: vec![path_dedot::CWD.clone()],
             target_version: PythonVersion::Py310,
-            flake8_annotations: Default::default(),
-            flake8_bugbear: Default::default(),
-            flake8_quotes: Default::default(),
-            flake8_tidy_imports: Default::default(),
-            isort: Default::default(),
-            mccabe: Default::default(),
-            pep8_naming: Default::default(),
-            show_source: Default::default(),
+            flake8_annotations: flake8_annotations::settings::Settings::default(),
+            flake8_bugbear: flake8_bugbear::settings::Settings::default(),
+            flake8_quotes: flake8_quotes::settings::Settings::default(),
+            flake8_tidy_imports: flake8_tidy_imports::settings::Settings::default(),
+            isort: isort::settings::Settings::default(),
+            mccabe: mccabe::settings::Settings::default(),
+            pep8_naming: pep8_naming::settings::Settings::default(),
+            show_source: false,
         }
     }
 
@@ -107,20 +107,20 @@ impl Settings {
             dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$").unwrap(),
             enabled: FxHashSet::from_iter(check_codes.clone()),
             fixable: FxHashSet::from_iter(check_codes),
-            exclude: Default::default(),
-            extend_exclude: Default::default(),
+            exclude: vec![],
+            extend_exclude: vec![],
             line_length: 88,
-            per_file_ignores: Default::default(),
+            per_file_ignores: vec![],
             src: vec![path_dedot::CWD.clone()],
             target_version: PythonVersion::Py310,
-            flake8_annotations: Default::default(),
-            flake8_bugbear: Default::default(),
-            flake8_quotes: Default::default(),
-            flake8_tidy_imports: Default::default(),
-            isort: Default::default(),
-            mccabe: Default::default(),
-            pep8_naming: Default::default(),
-            show_source: Default::default(),
+            flake8_annotations: flake8_annotations::settings::Settings::default(),
+            flake8_bugbear: flake8_bugbear::settings::Settings::default(),
+            flake8_quotes: flake8_quotes::settings::Settings::default(),
+            flake8_tidy_imports: flake8_tidy_imports::settings::Settings::default(),
+            isort: isort::settings::Settings::default(),
+            mccabe: mccabe::settings::Settings::default(),
+            pep8_naming: pep8_naming::settings::Settings::default(),
+            show_source: false,
         }
     }
 }
diff --git a/src/settings/pyproject.rs b/src/settings/pyproject.rs
index dd9eab6a8d..191c10d2bf 100644
--- a/src/settings/pyproject.rs
+++ b/src/settings/pyproject.rs
@@ -89,7 +89,7 @@ pub fn load_options(pyproject: Option<&PathBuf>) -> Result<Options> {
         None => {
             debug!("No pyproject.toml found.");
             debug!("Falling back to default configuration...");
-            Ok(Default::default())
+            Ok(Options::default())
         }
     }
 }
diff --git a/src/source_code_locator.rs b/src/source_code_locator.rs
index f7864d18a0..0b9149b421 100644
--- a/src/source_code_locator.rs
+++ b/src/source_code_locator.rs
@@ -17,7 +17,7 @@ impl<'a> SourceCodeLocator<'a> {
     pub fn new(contents: &'a str) -> Self {
         SourceCodeLocator {
             contents,
-            rope: Default::default(),
+            rope: OnceCell::default(),
         }
     }