Method discriminator

crates/csskit_derives/src/parse.rs:388–439

(&self, shared_atom_paths: &[String], hoisted_type_var_names: &[&Ident])

	}

	fn discriminator(&self, shared_atom_paths: &[String], hoisted_type_var_names: &[&Ident]) -> TokenStream {
		let all_optional = self.fields.iter().all(|f| f.ty.is_option());
		let is_all_optional_must_occur =
			matches!(self.parse_mode, FieldParseMode::OneMustOccur | FieldParseMode::AllMustOccur) && all_optional;
		if is_all_optional_must_occur {
			let peeks: Vec<TokenStream> = self
				.fields
				.iter()
				.filter(|f| {
					f.atom_path_string().is_none_or(|ap| !shared_atom_paths.contains(&ap))
						&& !hoisted_type_var_names.contains(&&f.var)
				})
				.map(|f| f.peek_tokens())
				.collect();
			if !peeks.is_empty() {
				return quote! { #(#peeks)||* };
			}
		}

		let discriminating =
			self.fields.iter().find(|f| f.atom_path_string().is_some_and(|ap| !shared_atom_paths.contains(&ap)));
		if let Some(field) = discriminating {
			return field.peek_tokens();
		}

		if let Some(field) = self.fields.iter().find(|f| f.atom.is_some()) {
			return field.peek_tokens();
		}

		let peek_types: Vec<Type> = self
			.fields
			.iter()
			.filter(|f| !hoisted_type_var_names.contains(&&f.var))
			.scan(true, |still_optional, f| {
				if !*still_optional {
					return None;
				}
				if !f.ty.is_option() {
					*still_optional = false;
				}
				Some(f.ty.unpack_option())
			})
			.collect();
		let type_checks: Vec<TokenStream> = peek_types.iter().map(|t| quote! { p.peek::<#t>() }).collect();
		if type_checks.len() == 1 {
			type_checks.into_iter().next().expect("len checked")
		} else if type_checks.is_empty() {
			quote! { false }
		} else {
			quote! { #(#type_checks)||* }
		}
	}

	fn body_with_hoisted(&self, hoisted: &[&Ident], where_collector: &mut WhereCollector) -> TokenStream {
		let ident = &self.ident;