Detect compile-time binding cycles

Signed-off-by: Johannes Löthberg <[email protected]>

Author: kyrias

core/src/analyze.rs

@@ -20,6 +20,11 @@ pub enum AnalyzeError {
         first: proc_macro2::Ident,
         second: proc_macro2::Ident,
     },
+    #[error("found cycle in compile-time bindings: {path}")]
+    CompileTimeBindingCycleDetected {
+        root_ident: proc_macro2::Ident,
+        path: String,
+    },
 }
 
 /// This represents the finished second step in the processing pipeline.
@@ -129,13 +134,87 @@ pub(crate) fn analyze(
         });
     }
 
+    compile_time_bindings::validate_compile_time_bindings(&compile_time_bindings)?;
+
     Ok(AnalyzedConditionalQueryAs {
         output_type: parsed.output_type,
         query_string: parsed.query_string,
         compile_time_bindings,
     })
 }
 
+mod compile_time_bindings {
+    use std::collections::{HashMap, HashSet};
+
+    use super::{AnalyzeError, CompileTimeBinding};
+
+    pub(super) fn validate_compile_time_bindings(
+        compile_time_bindings: &[CompileTimeBinding],
+    ) -> Result<(), AnalyzeError> {
+        let mut bindings = HashMap::new();
+
+        for (_, binding_values) in compile_time_bindings
+            .iter()
+            .flat_map(|bindings| &bindings.arms)
+        {
+            for (binding, value) in binding_values {
+                let name = binding.to_string();
+
+                let (_, references) = bindings
+                    .entry(name)
+                    .or_insert_with(|| (binding, HashSet::new()));
+                fill_references(references, &value.value());
+            }
+        }
+
+        for (name, (ident, _)) in &bindings {
+            validate_references(&bindings, ident, &[], name)?;
+        }
+
+        Ok(())
+    }
+
+    fn fill_references(references: &mut HashSet<String>, mut fragment: &str) {
+        while let Some(start_idx) = fragment.find("{#") {
+            fragment = &fragment[start_idx + 2..];
+            if let Some(end_idx) = fragment.find("}") {
+                references.insert(fragment[..end_idx].to_string());
+                fragment = &fragment[end_idx + 1..];
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn validate_references(
+        bindings: &HashMap<String, (&syn::Ident, HashSet<String>)>,
+        root_ident: &syn::Ident,
+        path: &[&str],
+        name: &str,
+    ) -> Result<(), AnalyzeError> {
+        let mut path = path.to_vec();
+        path.push(name);
+
+        if path.iter().filter(|component| **component == name).count() > 1 {
+            return Err(AnalyzeError::CompileTimeBindingCycleDetected {
+                root_ident: root_ident.clone(),
+                path: path.join(" -> "),
+            });
+        }
+
+        let Some((_, references)) = bindings.get(name) else {
+            // This error is caught and handled in all contexts in the expand stage.
+            return Ok(());
+        };
+
+        for reference in references {
+            validate_references(bindings, root_ident, &path, reference)?;
+        }
+
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use quote::ToTokens;
@@ -253,4 +332,27 @@ mod tests {
             AnalyzeError::DuplicatedCompileTimeBindingsFound { .. }
         ));
     }
+
+    #[test]
+    fn compile_time_binding_cycle_detected() {
+        let parsed = syn::parse_str::<ParsedConditionalQueryAs>(
+            r##"
+                SomeType,
+                r#"{#a}"#,
+                #a = match _ {
+                    _ => "{#b}",
+                },
+                #b = match _ {
+                    _ => "{#a}",
+                },
+            "##,
+        )
+        .unwrap();
+        let analyzed = analyze(parsed.clone()).unwrap_err();
+
+        assert!(matches!(
+            analyzed,
+            AnalyzeError::CompileTimeBindingCycleDetected { .. }
+        ));
+    }
 }

macros/src/lib.rs

@@ -44,6 +44,11 @@ pub fn conditional_query_as(input: proc_macro::TokenStream) -> proc_macro::Token
             AnalyzeError::DuplicatedCompileTimeBindingsFound { first: _, second } => {
                 abort!(second.span(), "found duplicate compile-time binding")
             }
+            AnalyzeError::CompileTimeBindingCycleDetected { root_ident, path } => abort!(
+                root_ident.span(),
+                "detected compile-time binding cycle: {}",
+                path
+            ),
         },
         Err(Error::ExpandError(err)) => match err {
             // TODO: Make this span point at the binding reference.  Requires https://github.com/rust-lang/rust/issues/54725