mirror of
https://github.com/GraphiteEditor/Graphite.git
synced 2026-09-15 22:28:10 +08:00
510 lines
20 KiB
Rust
510 lines
20 KiB
Rust
use crate::parsing::{Implementation, NodeParsedField, ParsedField, ParsedFieldType, ParsedNodeFn, RegularParsedField, attr_marker, record_writes, remove_attr_marker};
|
|
use proc_macro_error2::emit_error;
|
|
use quote::{ToTokens, quote};
|
|
use syn::spanned::Spanned;
|
|
use syn::{GenericParam, Type};
|
|
|
|
pub fn validate_node_fn(parsed: &ParsedNodeFn) -> syn::Result<()> {
|
|
let validators: &[fn(&ParsedNodeFn)] = &[
|
|
// Add more validators here as needed
|
|
validate_implementations_for_generics,
|
|
validate_primary_input_expose,
|
|
validate_min_max,
|
|
validate_range_slider_bounds,
|
|
validate_async_source,
|
|
validate_lend_fields,
|
|
validate_record_io,
|
|
validate_lazy_reads,
|
|
];
|
|
|
|
for validator in validators {
|
|
validator(parsed);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn validate_record_io(parsed: &ParsedNodeFn) {
|
|
let value = crate::codegen::slot_value_type(&parsed.output_type);
|
|
if let Type::Tuple(tuple) = &value {
|
|
let has_marker_slot = tuple.elems.iter().any(|slot| attr_marker(slot).is_some() || remove_attr_marker(slot).is_some());
|
|
if has_marker_slot && record_writes(&value).is_none() {
|
|
emit_error!(
|
|
parsed.output_type.span(),
|
|
"a record return tuple is the element first, then only `Attr<..>` writes and `RemoveAttr<..>` deletions"
|
|
);
|
|
}
|
|
} else if attr_marker(&value).is_some() || remove_attr_marker(&value).is_some() {
|
|
emit_error!(parsed.output_type.span(), "an attribute write needs an element in the first tuple slot, e.g. `(T, Attr<..>)`");
|
|
}
|
|
|
|
let writes = record_writes(&value);
|
|
let has_reads = parsed.fields.iter().any(|field| !field.attribute_reads.is_empty() && matches!(field.ty, ParsedFieldType::Regular(_)));
|
|
if !has_reads && writes.is_none() {
|
|
return;
|
|
}
|
|
|
|
let async_source = crate::codegen::classify::is_async_source(parsed);
|
|
if async_source && has_reads {
|
|
emit_error!(parsed.fn_name.span(), "attribute reads are not supported on async source kernels, only writes");
|
|
}
|
|
if crate::codegen::is_poll_kernel(&parsed.output_type) {
|
|
emit_error!(parsed.output_type.span(), "attribute io needs a plain or `Result<_, Interrupt>` kernel, not a `GPoll` one");
|
|
}
|
|
|
|
for field in parsed.fields.iter().skip(1) {
|
|
if let ParsedFieldType::Node(NodeParsedField { output_type, .. }) = &field.ty {
|
|
// Lazy secondaries are consumed as plain elements through the wire.
|
|
if crate::codegen::classify::is_served(output_type) || crate::codegen::ir::strip_ilist(output_type).1 > 0 {
|
|
emit_error!(field.pat_ident.span(), "a record node's lazy inputs consume plain elements, not record or ranked wires");
|
|
}
|
|
if !field.attribute_reads.is_empty() {
|
|
emit_error!(field.pat_ident.span(), "attribute reads on a record node's lazy inputs are not supported yet");
|
|
}
|
|
}
|
|
}
|
|
for (index, field) in parsed.fields.iter().enumerate() {
|
|
if field.attribute_reads.is_empty() {
|
|
continue;
|
|
}
|
|
if field.is_data_field {
|
|
emit_error!(field.pat_ident.span(), "a `#[data]` field has no wire to read attributes from");
|
|
continue;
|
|
}
|
|
match &field.ty {
|
|
ParsedFieldType::Regular(RegularParsedField { lend: Some(_), .. }) => {
|
|
emit_error!(field.pat_ident.span(), "attribute reads need an owned value; take `T` instead of `&T`");
|
|
}
|
|
ParsedFieldType::Regular(RegularParsedField { ty, implementations, .. }) => {
|
|
if matches!(ty, Type::Tuple(tuple) if tuple.elems.is_empty()) {
|
|
emit_error!(field.pat_ident.span(), "attribute-only inputs are not supported yet; the value component cannot be `()`");
|
|
}
|
|
let is_token_carrier = index == 0 && implementations.is_empty() && crate::codegen::unbounded_generic(parsed, ty).is_some();
|
|
if !is_token_carrier && crate::codegen::contains_open_generic(parsed, ty) {
|
|
emit_error!(
|
|
field.pat_ident.span(),
|
|
"a reading input's value is monomorphic for now; use a concrete type or an unbounded passthrough generic in the primary input"
|
|
);
|
|
}
|
|
}
|
|
// Lazy-input reads are validated by `validate_lazy_reads`; a
|
|
// record-io node already rejects lazy inputs above.
|
|
ParsedFieldType::Node(_) => {}
|
|
}
|
|
}
|
|
|
|
let Some(carrier) = parsed.fields.first() else {
|
|
emit_error!(parsed.fn_name.span(), "attribute io needs a primary input as the first parameter after the context (`_: ()` for none)");
|
|
return;
|
|
};
|
|
let lazy_carrier = matches!(&crate::codegen::record_shape(parsed), Some(shape) if matches!(shape.carrier, crate::codegen::RecordCarrier::LazyToken));
|
|
let carrier_ty = match &carrier.ty {
|
|
ParsedFieldType::Regular(RegularParsedField { ty, lend: None, .. }) if !carrier.is_data_field => Some(ty),
|
|
ParsedFieldType::Node(NodeParsedField { output_type, .. }) if lazy_carrier => Some(output_type),
|
|
_ => None,
|
|
};
|
|
let Some(carrier_ty) = carrier_ty else {
|
|
emit_error!(
|
|
carrier.pat_ident.span(),
|
|
"a record node's primary input is an owned element, an unbounded passthrough generic, a lazy passthrough source, or `_: ()`; not `#[data]` or `&T`"
|
|
);
|
|
return;
|
|
};
|
|
let node = crate::codegen::ir::build(parsed);
|
|
if lazy_carrier && !node.derives {
|
|
emit_error!(parsed.input.pat_ident.span(), "a lazy record carrier evaluates at derived contexts; spell `impl Ctx + DeriveCtx`");
|
|
return;
|
|
}
|
|
if node.output.gathers && crate::codegen::ir::gathered_subject(&node).is_none() {
|
|
emit_error!(parsed.output_type.span(), "a `Lane` output gathers a materialized subject; give the primary input an `IList` type");
|
|
return;
|
|
}
|
|
|
|
let no_carrier = matches!(carrier_ty, Type::Tuple(tuple) if tuple.elems.is_empty());
|
|
let token = match (no_carrier, &carrier.ty) {
|
|
(false, ParsedFieldType::Regular(RegularParsedField { ty, implementations, .. })) if implementations.is_empty() => crate::codegen::unbounded_generic(parsed, ty),
|
|
(false, ParsedFieldType::Node(NodeParsedField { output_type, .. })) if lazy_carrier => crate::codegen::unbounded_generic(parsed, output_type),
|
|
_ => None,
|
|
};
|
|
if async_source && token.is_some() {
|
|
emit_error!(carrier.pat_ident.span(), "an async source's element crosses the future boundary as a value; a passthrough generic element has none");
|
|
}
|
|
let element = writes.as_ref().map(|writes| &writes.element).unwrap_or(&value);
|
|
match &token {
|
|
Some(token) => {
|
|
if !matches!(crate::codegen::bare_ident(element), Some(ident) if ident == token) {
|
|
emit_error!(parsed.output_type.span(), "a generic element passes through unchanged: return `{}` in the first tuple position", token);
|
|
}
|
|
}
|
|
None => {
|
|
if let Some(ident) = crate::codegen::unbounded_generic(parsed, element) {
|
|
emit_error!(parsed.output_type.span(), "the returned generic element `{}` has no matching input", ident);
|
|
} else if !no_carrier && !node.output.gathers && crate::codegen::contains_open_generic(parsed, carrier_ty) {
|
|
emit_error!(
|
|
carrier.pat_ident.span(),
|
|
"record element reads are monomorphic for now; use a concrete element type or an unbounded passthrough generic"
|
|
);
|
|
} else if !node.output.gathers && crate::codegen::contains_open_generic(parsed, element) {
|
|
emit_error!(parsed.output_type.span(), "a written element must be a concrete type");
|
|
}
|
|
}
|
|
}
|
|
|
|
for field in &parsed.fields {
|
|
let mut seen_reads: Vec<String> = Vec::new();
|
|
for read in &field.attribute_reads {
|
|
let marker = read.marker.to_token_stream().to_string();
|
|
if seen_reads.contains(&marker) {
|
|
emit_error!(read.pat_ident.span(), "attribute `{}` is read twice from `{}`", marker, field.pat_ident.ident);
|
|
}
|
|
seen_reads.push(marker);
|
|
}
|
|
}
|
|
if let Some(writes) = &writes {
|
|
let mut seen_writes: Vec<String> = Vec::new();
|
|
for marker in &writes.markers {
|
|
let written = marker.to_token_stream().to_string();
|
|
if seen_writes.contains(&written) {
|
|
emit_error!(parsed.output_type.span(), "attribute `{}` is written twice", written);
|
|
}
|
|
seen_writes.push(written);
|
|
}
|
|
let mut seen_removes: Vec<String> = Vec::new();
|
|
for marker in &writes.removes {
|
|
let removed = marker.to_token_stream().to_string();
|
|
if seen_removes.contains(&removed) {
|
|
emit_error!(parsed.output_type.span(), "attribute `{}` is removed twice", removed);
|
|
}
|
|
if seen_writes.contains(&removed) {
|
|
emit_error!(parsed.output_type.span(), "attribute `{}` is both written and removed", removed);
|
|
}
|
|
seen_removes.push(removed);
|
|
}
|
|
if no_carrier && !writes.removes.is_empty() {
|
|
emit_error!(parsed.output_type.span(), "a node without a primary input writes a fresh record; there is nothing to remove");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn validate_lazy_reads(parsed: &ParsedNodeFn) {
|
|
if !crate::codegen::has_lazy_reads(parsed) {
|
|
return;
|
|
}
|
|
let lazy_carrier = matches!(&crate::codegen::record_shape(parsed), Some(shape) if matches!(shape.carrier, crate::codegen::RecordCarrier::LazyToken));
|
|
if !crate::codegen::record_flip(parsed) && !lazy_carrier {
|
|
emit_error!(
|
|
parsed.fn_name.span(),
|
|
"attribute reads on a lazy input need the record lowering; routing, `plain`, shader, batch, and non-row-assignable generic nodes keep the plain one"
|
|
);
|
|
}
|
|
for (index, field) in parsed.fields.iter().enumerate() {
|
|
let ParsedFieldType::Node(NodeParsedField { output_type, .. }) = &field.ty else {
|
|
continue;
|
|
};
|
|
if field.attribute_reads.is_empty() {
|
|
continue;
|
|
}
|
|
// The lazy carrier forwards its token AND reads: the reads resolve
|
|
// against its wired layout, not the row type.
|
|
if crate::codegen::unbounded_generic(parsed, output_type).is_some() && !(lazy_carrier && index == 0) {
|
|
emit_error!(
|
|
field.pat_ident.span(),
|
|
"an unbounded generic source forwards its whole record; attribute reads need a concrete output type"
|
|
);
|
|
}
|
|
let mut seen: Vec<String> = Vec::new();
|
|
for read in &field.attribute_reads {
|
|
let marker = read.marker.to_token_stream().to_string();
|
|
if seen.contains(&marker) {
|
|
emit_error!(read.marker.span(), "attribute `{}` is read twice from `{}`", marker, field.pat_ident.ident);
|
|
}
|
|
seen.push(marker);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn validate_async_source(parsed: &ParsedNodeFn) {
|
|
let snapshot_ctx = matches!(&parsed.input.ty, Type::Path(path) if path.path.segments.last().is_some_and(|segment| segment.ident == "CtxSnapshot"));
|
|
let future_kernel = crate::codegen::is_source_kernel(&parsed.output_type);
|
|
if let Some(placeholder) = &parsed.attributes.placeholder
|
|
&& !parsed.is_async
|
|
&& !future_kernel
|
|
{
|
|
emit_error!(
|
|
placeholder.span(),
|
|
"`placeholder` applies only to async and source kernels; a synchronous node never reports `Partial`, so the stand-in is unused"
|
|
);
|
|
}
|
|
if parsed.is_async && future_kernel {
|
|
emit_error!(
|
|
parsed.output_type.span(),
|
|
"an `async fn` kernel already is the async part; returning `SourceFuture` is the sync-prologue form, so drop the `async` keyword or return the value directly"
|
|
);
|
|
return;
|
|
}
|
|
if !parsed.is_async {
|
|
if snapshot_ctx {
|
|
emit_error!(
|
|
parsed.input.pat_ident.span(),
|
|
"`CtxSnapshot` is the async source context; synchronous nodes take `impl Ctx` and read through extract bounds"
|
|
);
|
|
}
|
|
if !future_kernel {
|
|
return;
|
|
}
|
|
}
|
|
if parsed.is_async {
|
|
for field in &parsed.fields {
|
|
if matches!(field.ty, ParsedFieldType::Node(_)) {
|
|
emit_error!(
|
|
field.pat_ident.span(),
|
|
"`async fn` source nodes cannot take `impl Node` inputs: the spawned future outlives any borrow of the graph, so it cannot evaluate other nodes; use the sync-prologue form (return `SourceFuture`) to evaluate lazy inputs before spawning"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn validate_lend_fields(parsed: &ParsedNodeFn) {
|
|
let future_kernel = crate::codegen::is_source_kernel(&parsed.output_type);
|
|
for field in &parsed.fields {
|
|
let ParsedFieldType::Regular(RegularParsedField { lend: Some(reference), .. }) = &field.ty else {
|
|
continue;
|
|
};
|
|
if let Some(mutability) = &reference.mutability {
|
|
emit_error!(mutability.span(), "reference parameters are read-only lends; `&mut` is not supported");
|
|
}
|
|
if let Some(lifetime) = &reference.lifetime {
|
|
emit_error!(lifetime.span(), "reference parameters use the eval lifetime implicitly; write a bare `&T`");
|
|
}
|
|
if field.is_data_field {
|
|
emit_error!(field.pat_ident.span(), "`#[data]` fields are node-resident state and cannot be references");
|
|
}
|
|
if parsed.is_async || future_kernel {
|
|
emit_error!(
|
|
field.pat_ident.span(),
|
|
"source kernels move their inputs into the spawned task, so they cannot take reference parameters"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn validate_min_max(parsed: &ParsedNodeFn) {
|
|
for field in &parsed.fields {
|
|
if let ParsedField {
|
|
ty: ParsedFieldType::Regular(RegularParsedField {
|
|
number_hard_max,
|
|
number_hard_min,
|
|
number_soft_max,
|
|
number_soft_min,
|
|
..
|
|
}),
|
|
pat_ident,
|
|
..
|
|
} = field
|
|
{
|
|
if let (Some(soft_min), Some(hard_min)) = (number_soft_min, number_hard_min) {
|
|
let soft_min_value: f64 = soft_min.to_f64();
|
|
let hard_min_value: f64 = hard_min.to_f64();
|
|
if soft_min_value == hard_min_value {
|
|
emit_error!(
|
|
pat_ident.span(),
|
|
"Redundant lower bound on `{}`: the #[soft] and #[hard] lower bounds are equal.",
|
|
pat_ident.ident;
|
|
help = "Drop the lower bound from #[soft] and let the slider fall back to #[hard].";
|
|
note = "A soft bound only matters when it sits inside the corresponding hard bound.",
|
|
);
|
|
} else if soft_min_value < hard_min_value {
|
|
emit_error!(
|
|
pat_ident.span(),
|
|
"The #[soft] lower bound on `{}` is below the #[hard] lower bound.",
|
|
pat_ident.ident;
|
|
help = "The soft (slider) range must stay within the hard (clamped) range.";
|
|
note = "Letting the slider range precede #[hard]'s lower bound doesn't make sense.",
|
|
);
|
|
}
|
|
}
|
|
|
|
if let (Some(soft_max), Some(hard_max)) = (number_soft_max, number_hard_max) {
|
|
let soft_max_value: f64 = soft_max.to_f64();
|
|
let hard_max_value: f64 = hard_max.to_f64();
|
|
if soft_max_value == hard_max_value {
|
|
emit_error!(
|
|
pat_ident.span(),
|
|
"Redundant upper bound on `{}`: the #[soft] and #[hard] upper bounds are equal.",
|
|
pat_ident.ident;
|
|
help = "Drop the upper bound from #[soft] and let the slider fall back to #[hard].";
|
|
note = "A soft bound only matters when it sits inside the corresponding hard bound.",
|
|
);
|
|
} else if soft_max_value > hard_max_value {
|
|
emit_error!(
|
|
pat_ident.span(),
|
|
"The #[soft] upper bound on `{}` is above the #[hard] upper bound.",
|
|
pat_ident.ident;
|
|
help = "The soft (slider) range must stay within the hard (clamped) range.";
|
|
note = "Letting the slider range exceed #[hard]'s upper bound doesn't make sense.",
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A `#[range]` slider needs a defined extent on both ends. The extent comes from `#[soft]` when present,
|
|
/// otherwise it falls back to `#[hard]`, so each end must be covered by at least one of the two attributes.
|
|
fn validate_range_slider_bounds(parsed: &ParsedNodeFn) {
|
|
for field in &parsed.fields {
|
|
if let ParsedField {
|
|
ty: ParsedFieldType::Regular(RegularParsedField {
|
|
number_mode_range: true,
|
|
number_soft_min,
|
|
number_soft_max,
|
|
number_hard_min,
|
|
number_hard_max,
|
|
..
|
|
}),
|
|
pat_ident,
|
|
..
|
|
} = field
|
|
{
|
|
let min_bounded = number_soft_min.is_some() || number_hard_min.is_some();
|
|
let max_bounded = number_soft_max.is_some() || number_hard_max.is_some();
|
|
|
|
let missing = match (min_bounded, max_bounded) {
|
|
(true, true) => continue,
|
|
(false, false) => "lower and upper bounds",
|
|
(false, true) => "a lower bound",
|
|
(true, false) => "an upper bound",
|
|
};
|
|
|
|
emit_error!(
|
|
pat_ident.span(),
|
|
"The #[range] slider on `{}` is missing {}.",
|
|
pat_ident.ident, missing;
|
|
help = "A slider needs both ends defined; add the missing bound via #[soft(..)] or #[hard(..)], e.g. #[soft(0..100)].";
|
|
note = "The slider's extent comes from #[soft] if present, otherwise #[hard].",
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn validate_primary_input_expose(parsed: &ParsedNodeFn) {
|
|
if let Some(ParsedField {
|
|
ty: ParsedFieldType::Regular(RegularParsedField { exposed: true, .. }),
|
|
pat_ident,
|
|
..
|
|
}) = parsed.fields.first()
|
|
{
|
|
emit_error!(
|
|
pat_ident.span(),
|
|
"Unnecessary #[expose] attribute on primary input `{}`. Primary inputs are always exposed.",
|
|
pat_ident.ident;
|
|
help = "You can safely remove the #[expose] attribute from this field.";
|
|
note = "The function's second argument, `{}`, is the node's primary input and it's always exposed by default", pat_ident.ident
|
|
);
|
|
}
|
|
}
|
|
|
|
fn validate_implementations_for_generics(parsed: &ParsedNodeFn) {
|
|
let has_skip_impl = parsed.attributes.skip_impl;
|
|
let routing = crate::codegen::routing_io(parsed);
|
|
let node = crate::codegen::ir::build(parsed);
|
|
let record_token = match (crate::codegen::ir::node_kind(&node), &node.output.shape.element) {
|
|
(crate::codegen::ir::NodeKind::RecordIo, crate::codegen::ir::Element::Generic(ident)) => Some(ident.clone()),
|
|
_ => None,
|
|
};
|
|
let opaque_record_generic = |ty: &Type| {
|
|
let (stripped, _) = crate::codegen::ir::strip_ilist(ty);
|
|
let ident = match &stripped {
|
|
Type::Path(path) => path.path.get_ident(),
|
|
_ => None,
|
|
};
|
|
ident.is_some() && (ident == routing.as_ref().map(|routing| &routing.generic) || ident == record_token.as_ref())
|
|
};
|
|
|
|
if !has_skip_impl && !parsed.fn_generics.is_empty() {
|
|
for field in &parsed.fields {
|
|
// Skip validation for data fields - they're internal state and can be generic
|
|
if field.is_data_field {
|
|
continue;
|
|
}
|
|
|
|
let pat_ident = &field.pat_ident;
|
|
match &field.ty {
|
|
ParsedFieldType::Regular(RegularParsedField { ty, implementations, .. }) => {
|
|
if opaque_record_generic(ty) {
|
|
continue;
|
|
}
|
|
if contains_generic_param(ty, &parsed.fn_generics) && implementations.is_empty() {
|
|
emit_error!(
|
|
ty.span(),
|
|
"Generic type `{}` in field `{}` requires an #[implementations(...)] attribute",
|
|
quote!(#ty),
|
|
pat_ident.ident;
|
|
help = "Add #[implementations(ConcreteType1, ConcreteType2)] to field '{}'", pat_ident.ident;
|
|
help = "Or use #[node_macro::node(category(...), skip_impl)] if you want to manually implement the node"
|
|
);
|
|
}
|
|
}
|
|
ParsedFieldType::Node(NodeParsedField {
|
|
input_type,
|
|
output_type,
|
|
implementations,
|
|
..
|
|
}) => {
|
|
if opaque_record_generic(output_type) {
|
|
continue;
|
|
}
|
|
if (contains_generic_param(input_type, &parsed.fn_generics) || contains_generic_param(output_type, &parsed.fn_generics)) && implementations.is_empty() {
|
|
emit_error!(
|
|
pat_ident.span(),
|
|
"Generic types in Node field `{}` require an #[implementations(...)] attribute",
|
|
pat_ident.ident;
|
|
help = "Add #[implementations(InputType1 -> OutputType1, InputType2 -> OutputType2)] to field '{}'", pat_ident.ident;
|
|
help = "Or use #[node_macro::node(category(...), skip_impl)] if you want to manually implement the node"
|
|
);
|
|
}
|
|
// Additional check for Node implementations
|
|
for impl_ in implementations {
|
|
validate_node_implementation(impl_, input_type, output_type, &parsed.fn_generics);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn validate_node_implementation(impl_: &Implementation, input_type: &Type, output_type: &Type, fn_generics: &[GenericParam]) {
|
|
if contains_generic_param(&impl_.input, fn_generics) || contains_generic_param(&impl_.output, fn_generics) {
|
|
emit_error!(
|
|
impl_.input.span(),
|
|
"Implementation types `{}` and `{}` must be concrete, not generic",
|
|
quote!(#input_type), quote!(#output_type);
|
|
help = "Replace generic types with concrete types in the implementation"
|
|
);
|
|
}
|
|
}
|
|
|
|
fn contains_generic_param(ty: &Type, fn_generics: &[GenericParam]) -> bool {
|
|
struct GenericParamChecker<'a> {
|
|
fn_generics: &'a [GenericParam],
|
|
found: bool,
|
|
}
|
|
|
|
impl<'a> syn::visit::Visit<'a> for GenericParamChecker<'a> {
|
|
fn visit_ident(&mut self, ident: &'a syn::Ident) {
|
|
if self
|
|
.fn_generics
|
|
.iter()
|
|
.any(|param| if let GenericParam::Type(type_param) = param { type_param.ident == *ident } else { false })
|
|
{
|
|
self.found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut checker = GenericParamChecker { fn_generics, found: false };
|
|
syn::visit::visit_type(&mut checker, ty);
|
|
checker.found
|
|
}
|