Function parse_node_fn

node-graph/node-macro/src/parsing.rs:500–547

(attr: TokenStream2, item: TokenStream2)

}

fn parse_node_fn(attr: TokenStream2, item: TokenStream2) -> syn::Result<ParsedNodeFn> {
	let attributes = syn::parse2::<NodeFnAttributes>(attr.clone()).map_err(|e| Error::new(e.span(), format!("Failed to parse node_fn attributes:\n{e}")))?;
	let input_fn = syn::parse2::<ItemFn>(item.clone()).map_err(|e| Error::new(e.span(), format!("Failed to parse function: {e}. Make sure it's a valid Rust function.")))?;

	let vis = input_fn.vis;
	let fn_name = input_fn.sig.ident.clone();
	let struct_name = format_ident!("{}", fn_name.to_string().to_case(Case::Pascal));
	let mod_name = fn_name.clone();
	let fn_generics = input_fn.sig.generics.params.into_iter().collect();
	let is_async = input_fn.sig.asyncness.is_some();

	let (input, fields) = parse_inputs(&input_fn.sig.inputs)?;
	let output_type = parse_output(&input_fn.sig.output)?;
	let where_clause = input_fn.sig.generics.where_clause;
	let body = input_fn.block.to_token_stream();
	let description = input_fn
		.attrs
		.iter()
		.filter_map(|a| {
			if a.style != AttrStyle::Outer {
				return None;
			}
			let Meta::NameValue(name_val) = &a.meta else { return None };
			if name_val.path.get_ident().map(|x| x.to_string()) != Some("doc".into()) {
				return None;
			}
			let Expr::Lit(expr_lit) = &name_val.value else { return None };
			let Lit::Str(ref text) = expr_lit.lit else { return None };
			Some(text.value().trim().to_string())
		})
		.fold(String::new(), |acc, b| acc + &b + "\n");

	Ok(ParsedNodeFn {
		vis,
		attributes,
		fn_name,
		struct_name,
		mod_name,
		fn_generics,
		input,
		output_type,
		is_async,
		fields,
		where_clause,
		body,
		description,
	})
}

fn parse_inputs(inputs: &Punctuated<FnArg, Comma>) -> syn::Result<(Input, Vec<ParsedField>)> {
	let mut fields = Vec::new();