Clear the remaining clippy warnings on the diff surface

node-graph/node-macro/src/codegen.rs

@@ -197,7 +197,7 @@ pub(crate) fn generate_node_code(crate_ident: &CrateIdent, parsed: &ParsedNodeFn
 	let field_pushed_levels: Vec<u8> = regular_fields
 		.iter()
 		.map(|field| match &field.ty {
-			ParsedFieldType::Regular(RegularParsedField { list_levels, .. }) if *list_levels > 0 => *list_levels as u8,
+			ParsedFieldType::Regular(RegularParsedField { list_levels, .. }) if *list_levels > 0 => *list_levels,
 			ParsedFieldType::Node(_) => pushed_levels,
 			_ => 0,
 		})
@@ -2433,20 +2433,20 @@ pub(crate) fn generate_node_impl(crate_ident: &CrateIdent, parsed: &ParsedNodeFn
 				.iter()
 				.enumerate()
 				.filter(|(index, _)| ir::materialized_levels(&node, *index) == 0)
-				.filter_map(|(_, field)| match &field.ty {
+				.map(|(_, field)| match &field.ty {
 					// The conditional arena-park moves a lend element once.
-					ParsedFieldType::Regular(RegularParsedField { ty, lend: Some(_), .. }) => Some({
+					ParsedFieldType::Regular(RegularParsedField { ty, lend: Some(_), .. }) => {
 						let ty = &crate::codegen::classify::substitute_lifetimes(ty, "'static");
 						quote!(#ty: ::core::marker::Send + ::core::marker::Sync + 'static)
-					}),
-					ParsedFieldType::Regular(RegularParsedField { ty, .. }) => Some({
+					}
+					ParsedFieldType::Regular(RegularParsedField { ty, .. }) => {
 						let ty = &crate::codegen::classify::substitute_lifetimes(ty, "'static");
 						quote!(#ty: ::core::clone::Clone)
-					}),
-					ParsedFieldType::Node(NodeParsedField { output_type, .. }) => Some({
+					}
+					ParsedFieldType::Node(NodeParsedField { output_type, .. }) => {
 						let output_type = &crate::codegen::classify::substitute_lifetimes(output_type, "'static");
 						quote!(#output_type: ::core::clone::Clone)
-					}),
+					}
 				})
 				.collect();
 			let out = crate::codegen::classify::substitute_lifetimes(&slot_value_type(&parsed.output_type), "'static");

node-graph/node-macro/src/codegen/classify.rs

@@ -312,7 +312,7 @@ pub(crate) fn record_shape(parsed: &ParsedNodeFn) -> Option<RecordShape> {
 		ParsedFieldType::Node(NodeParsedField { output_type, .. }) => is_served(output_type) || crate::codegen::ir::strip_ilist(output_type).1 > 0 || !field.attribute_reads.is_empty(),
 		ParsedFieldType::Regular(_) => false,
 	};
-	if parsed.fields.iter().skip(lazy_carrier as usize).any(|field| unsupported_lazy_secondary(field)) {
+	if parsed.fields.iter().skip(lazy_carrier as usize).any(unsupported_lazy_secondary) {
 		return None;
 	}
 	let reads_well_placed = parsed.fields.iter().enumerate().all(|(index, field)| {
@@ -575,7 +575,7 @@ pub(crate) fn routing_io(parsed: &ParsedNodeFn) -> Option<RoutingIo> {
 			}
 		}
 	}
-	(sources > 0).then(|| RoutingIo { generic: ident })
+	(sources > 0).then_some(RoutingIo { generic: ident })
 }
 
 pub(crate) fn bare_ident(ty: &Type) -> Option<&Ident> {

node-graph/node-macro/src/codegen/entries.rs

@@ -100,7 +100,7 @@ fn flip_entries_tokens(parsed: &ParsedNodeFn, struct_name: &Ident, regular_field
 		}
 	}
 	let alias_params: Vec<&GenericParam> = candidate_params.iter().zip(&kept).filter(|(_, kept)| **kept).map(|(param, _)| *param).collect();
-	let alias_param_idents: Vec<Ident> = alias_params.iter().map(|param| param_ident(param)).collect();
+	let alias_param_idents: Vec<Ident> = alias_params.iter().map(param_ident).collect();
 	let alias_param_tokens: Vec<TokenStream2> = alias_params.iter().map(|param| quote!(#param)).collect();
 	let output_alias = format_ident!("__{}_output", fn_name);
 	let alias_def = match alias_param_tokens.is_empty() {

node-graph/node-macro/src/codegen/ir.rs

@@ -48,7 +48,7 @@ fn generics(parsed: &ParsedNodeFn) -> Vec<Generic> {
 
 fn inputs(parsed: &ParsedNodeFn, fields: &[&ParsedField], generics: &[Ident]) -> Vec<Input> {
 	let routing = routing_io(parsed);
-	let carrier_subject = flip_carrier(parsed) || record_shape(parsed).map_or(false, |shape| !shape.skips_carrier());
+	let carrier_subject = flip_carrier(parsed) || record_shape(parsed).is_some_and(|shape| !shape.skips_carrier());
 	fields
 		.iter()
 		.enumerate()
@@ -263,13 +263,16 @@ fn ilist_inner(ty: &Type) -> Option<Type> {
 /// caller since it is the one row-dependent facet; the rest folds from the node.
 pub(crate) fn layout_meta_tokens(node: &Node, element_spec: TokenStream2, core_types: &TokenStream2) -> TokenStream2 {
 	let sources = layout_sources(node).into_iter().map(|index| index as u8);
-	let reads = node.inputs.iter().enumerate().filter_map(|(index, input)| {
-		(matches!(input.evaluation, Evaluation::Eager) && !input.shape.attrs.is_empty()).then(|| {
+	let reads = node
+		.inputs
+		.iter()
+		.enumerate()
+		.filter(|(_, input)| matches!(input.evaluation, Evaluation::Eager) && !input.shape.attrs.is_empty())
+		.map(|(index, input)| {
 			let descs = field_writes(&input.shape.attrs, core_types);
 			let index = index as u8;
 			quote!(#core_types::record::InputReads { input: #index, reads: ::std::vec![#(#descs),*] })
-		})
-	});
+		});
 	let writes = field_writes(&node.output.shape.attrs, core_types);
 	let removes = node.output.removes.iter().map(|attr| {
 		let marker = &attr.marker;
@@ -859,9 +862,7 @@ mod tests {
 		let routing_source = |ty: &Type| generic.as_ref().is_some_and(|generic| crate::codegen::classify::routing_source_output(ty, generic));
 		match &field.ty {
 			ParsedFieldType::Regular(RegularParsedField { ty, lend, .. }) => {
-				if record && !skips_carrier && index == 0 {
-					"carrier"
-				} else if carrier_flip && index == 0 {
+				if index == 0 && ((record && !skips_carrier) || carrier_flip) {
 					"carrier"
 				} else if flip && lend.is_some() {
 					"lend"