use std::collections::HashSet;
use std::sync::OnceLock;
use crate::compiler::dialects;
use crate::compiler::expr_translate::ExprTranslator;
use crate::errors::VerifyError;
use crate::parser::Json;
fn builtin_predicate_names() -> &'static HashSet<String> {
static BUILTINS: OnceLock<HashSet<String>> = OnceLock::new();
BUILTINS.get_or_init(|| {
let mut names = HashSet::new();
for engine in dialects::SUPPORTED_ENGINES {
if let Ok(dialect) = dialects::get(engine) {
names.extend(ExprTranslator::basis_functions(dialect.as_ref()));
}
}
names
})
}
fn record_defines_value(record: &Json) -> bool {
record
.as_object()
.get("field_value")
.map(|fvs| {
fvs.as_array().iter().any(|fv| {
matches!(fv.as_object().get("field"), Some(f) if f.is_string() && f.as_str() == "logica_value")
})
})
.unwrap_or(false)
}
#[derive(Debug, Clone)]
pub struct PositionalError {
pub predicate: String,
}
impl std::fmt::Display for PositionalError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"Positional arguments in '{}': Synalog requires named arguments — use `field_name: value` instead of positional arguments",
self.predicate
)
}
}
impl From<PositionalError> for VerifyError {
fn from(e: PositionalError) -> Self {
VerifyError::PositionalArguments {
predicate: e.predicate,
}
}
}
fn record_has_positional(record: &Json) -> bool {
record
.as_object()
.get("field_value")
.map(|fvs| {
fvs.as_array().iter().any(|fv| {
matches!(fv.as_object().get("field"), Some(field) if !field.is_string())
})
})
.unwrap_or(false)
}
fn collect_body_positional(node: &Json, value_preds: &HashSet<String>, out: &mut Vec<String>) {
match node {
Json::Object(obj) => {
if let Some(pred) = obj.get("predicate") {
let p = pred.as_object();
if let Some(record) = p.get("record") {
if record_has_positional(record) {
let name = p["predicate_name"].as_str();
if !builtin_predicate_names().contains(name)
&& !value_preds.contains(name)
{
out.push(name.to_string());
}
}
}
}
for v in obj.values() {
collect_body_positional(v, value_preds, out);
}
}
Json::Array(items) => {
for it in items {
collect_body_positional(it, value_preds, out);
}
}
_ => {}
}
}
pub fn check_positional(rules: &[&Json]) -> Vec<PositionalError> {
let value_preds: HashSet<String> = rules
.iter()
.filter(|rule| {
rule.as_object()["head"]
.as_object()
.get("record")
.map(record_defines_value)
.unwrap_or(false)
})
.map(|rule| {
rule.as_object()["head"].as_object()["predicate_name"]
.as_str()
.to_string()
})
.collect();
let mut seen = HashSet::new();
let mut errors = Vec::new();
for rule in rules {
let obj = rule.as_object();
let head = &obj["head"];
if head.as_object()["predicate_name"]
.as_str()
.starts_with('@')
{
continue;
}
if let Some(record) = head.as_object().get("record") {
if record_has_positional(record) && !record_defines_value(record) {
let name = head.as_object()["predicate_name"].as_str().to_string();
if seen.insert(name.clone()) {
errors.push(PositionalError { predicate: name });
}
}
}
if let Some(body) = obj.get("body") {
let mut names = Vec::new();
collect_body_positional(body, &value_preds, &mut names);
for name in names {
if seen.insert(name.clone()) {
errors.push(PositionalError { predicate: name });
}
}
}
}
errors
}
#[cfg(test)]
mod tests {
use super::*;
use crate::parser::parse_file;
fn rules(code: &str) -> Vec<&'static Json> {
let parsed: &'static Json = Box::leak(Box::new(parse_file(code, None, &[]).unwrap()));
parsed.as_object()["rule"].as_array().iter().collect()
}
#[test]
fn flags_positional_head() {
let r = rules("Customer(id, name) :- customers(id:, name:);");
let errs = check_positional(&r);
assert_eq!(errs.len(), 1);
assert_eq!(errs[0].predicate, "Customer");
}
#[test]
fn flags_positional_body_reference() {
let r = rules("Foo(x:) :- bar(x, y);");
let errs = check_positional(&r);
assert_eq!(errs.len(), 1);
assert_eq!(errs[0].predicate, "bar");
}
#[test]
fn named_program_is_clean() {
let r = rules("Customer(id:, name:) :- customers(id:, name:);");
assert!(check_positional(&r).is_empty());
}
#[test]
fn function_calls_are_not_flagged() {
let r = rules("Foo(y:) :- bar(s:), y == Substr(ToString(s), 1, 2);");
assert!(check_positional(&r).is_empty());
}
#[test]
fn annotations_are_not_flagged() {
let r = rules("@OrderBy(Foo, \"x\");\nFoo(x:) :- bar(x:);");
assert!(check_positional(&r).is_empty());
}
#[test]
fn one_error_per_predicate_name() {
let r = rules(
"Foo(a, b) :- bar(a:, b:);\n\
Foo(a, b) :- baz(a:, b:);",
);
assert_eq!(check_positional(&r).len(), 1);
}
#[test]
fn negation_is_not_flagged() {
let r = rules("Foo(id:) :- C(id:), ~L(id:);");
assert!(check_positional(&r).is_empty());
}
#[test]
fn constraint_is_not_flagged() {
let r = rules("Foo(id:) :- C(id:), Constraint(id > 0);");
assert!(check_positional(&r).is_empty());
}
#[test]
fn udf_definition_head_is_not_flagged() {
let r = rules("Square(x) = x * x;\nFoo(n:) :- C(n:), m == Square(n);");
assert!(check_positional(&r).is_empty());
}
#[test]
fn value_predicate_head_and_reference_are_not_flagged() {
let r = rules(
"Cost(\"w\") = 0;\n\
Cost(d) Min= c :- R(o: \"w\", d:, c:);\n\
Cost(d) Min= Cost(h) + c :- Cost(h), R(o: h, d:, c:);",
);
assert!(check_positional(&r).is_empty());
}
}