#![warn(missing_docs)]
use dsl_kit_core::{IdGen, NodeId};
use dsl_kit_schema::{ChildSchema, Multiplicity, NodeSchema, VariantSchema};
use serde_json::{Value, json};
use std::fmt;
pub mod example_gen;
pub mod grammar_check;
pub mod peg;
pub mod schema_gen;
pub mod serde_bridge;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Span {
pub start: usize,
pub end: usize,
}
impl Span {
pub const fn new(start: usize, end: usize) -> Self {
Self { start, end }
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum RawValue {
Text(String),
Json(Value),
}
#[derive(Debug, Clone, PartialEq)]
pub struct ParseTree {
pub variant: String,
pub fields: Vec<(String, RawValue)>,
pub children: Vec<(String, Vec<ParseTree>)>,
pub span: Option<Span>,
}
impl ParseTree {
pub fn new(variant: impl Into<String>) -> Self {
Self {
variant: variant.into(),
fields: Vec::new(),
children: Vec::new(),
span: None,
}
}
pub fn field(&self, name: &str) -> Option<&RawValue> {
self.fields.iter().find(|(n, _)| n == name).map(|(_, v)| v)
}
pub fn child_slot(&self, name: &str) -> Option<&[ParseTree]> {
self.children
.iter()
.find(|(n, _)| n == name)
.map(|(_, v)| v.as_slice())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Severity {
Error,
Warning,
Info,
}
impl Severity {
pub const fn as_str(self) -> &'static str {
match self {
Severity::Error => "error",
Severity::Warning => "warning",
Severity::Info => "info",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Location {
Span(Span),
Node(NodeId),
None,
}
impl Location {
pub fn to_json(&self) -> Value {
match self {
Location::Span(Span { start, end }) => {
json!({ "kind": "span", "start": start, "end": end })
}
Location::Node(id) => json!({ "kind": "node", "id": id.0 }),
Location::None => Value::Null,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Diagnostic {
pub severity: Severity,
pub code: String,
pub message: String,
pub location: Location,
}
impl Diagnostic {
pub fn error(code: impl Into<String>, message: impl Into<String>) -> Self {
Self {
severity: Severity::Error,
code: code.into(),
message: message.into(),
location: Location::None,
}
}
pub fn with_span(mut self, span: Option<Span>) -> Self {
if let Some(span) = span {
self.location = Location::Span(span);
}
self
}
pub fn with_node(mut self, id: NodeId) -> Self {
self.location = Location::Node(id);
self
}
pub fn to_json(&self) -> Value {
json!({
"severity": self.severity.as_str(),
"code": self.code,
"message": self.message,
"location": self.location.to_json(),
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BuildError {
pub diagnostics: Vec<Diagnostic>,
}
impl BuildError {
pub fn new(diagnostics: Vec<Diagnostic>) -> Self {
assert!(
!diagnostics.is_empty(),
"BuildError requires at least one diagnostic"
);
Self { diagnostics }
}
pub fn single(diag: Diagnostic) -> Self {
Self {
diagnostics: vec![diag],
}
}
pub fn to_json(&self) -> Value {
Value::Array(self.diagnostics.iter().map(Diagnostic::to_json).collect())
}
}
impl fmt::Display for BuildError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"build failed with {} diagnostic(s):",
self.diagnostics.len()
)?;
for d in &self.diagnostics {
write!(f, "\n [{}] {}: {}", d.severity.as_str(), d.code, d.message)?;
}
Ok(())
}
}
impl std::error::Error for BuildError {}
pub trait DslBuild: Sized {
fn from_parse_tree(tree: &ParseTree, ids: &IdGen) -> Result<Self, BuildError>;
}
pub mod codes {
pub const UNKNOWN_VARIANT: &str = "dsl_kit::parse::unknown_variant";
pub const MISSING_FIELD: &str = "dsl_kit::parse::missing_field";
pub const UNKNOWN_FIELD: &str = "dsl_kit::parse::unknown_field";
pub const UNKNOWN_CHILD: &str = "dsl_kit::parse::unknown_child";
pub const ARITY_ONE: &str = "dsl_kit::parse::arity_one";
pub const ARITY_OPTIONAL: &str = "dsl_kit::parse::arity_optional";
pub const FIELD_AS_CHILD: &str = "dsl_kit::parse::field_as_child";
pub const CHILD_AS_FIELD: &str = "dsl_kit::parse::child_as_field";
pub const DUPLICATE_FIELD: &str = "dsl_kit::parse::duplicate_field";
pub const DUPLICATE_CHILD: &str = "dsl_kit::parse::duplicate_child";
pub const FIELD_TYPE: &str = "dsl_kit::parse::field_type";
}
pub fn check_conformance(tree: &ParseTree, schema: &NodeSchema) -> Vec<Diagnostic> {
let mut out = Vec::new();
let Some(variant) = schema.variant(&tree.variant) else {
let candidates = nearest_candidates(&tree.variant, &schema.variants, 3);
let msg = if candidates.is_empty() {
format!("unknown variant `{}` for `{}`", tree.variant, schema.name)
} else {
format!(
"unknown variant `{}` for `{}` (did you mean: {})",
tree.variant,
schema.name,
candidates.join(", ")
)
};
out.push(Diagnostic::error(codes::UNKNOWN_VARIANT, msg).with_span(tree.span));
return out;
};
check_fields(tree, variant, &mut out);
check_children(tree, variant, &mut out);
out
}
fn check_fields(tree: &ParseTree, variant: &VariantSchema, out: &mut Vec<Diagnostic>) {
for i in 0..tree.fields.len() {
let (name, _) = &tree.fields[i];
if tree.fields[..i].iter().any(|(n, _)| n == name) {
out.push(
Diagnostic::error(
codes::DUPLICATE_FIELD,
format!(
"field `{}` appears more than once on variant `{}`",
name, variant.name
),
)
.with_span(tree.span),
);
}
}
for f in &variant.fields {
if tree.field(&f.name).is_none() {
out.push(
Diagnostic::error(
codes::MISSING_FIELD,
format!(
"variant `{}` is missing required field `{}` (type `{}`)",
variant.name, f.name, f.ty
),
)
.with_span(tree.span),
);
}
}
for (name, _) in &tree.fields {
if variant.fields.iter().any(|f| &f.name == name) {
continue;
}
if variant.children.iter().any(|c| &c.name == name) {
out.push(
Diagnostic::error(
codes::CHILD_AS_FIELD,
format!(
"`{}` on variant `{}` is a child slot, not a payload field \
(move it under `children`)",
name, variant.name
),
)
.with_span(tree.span),
);
} else {
out.push(
Diagnostic::error(
codes::UNKNOWN_FIELD,
format!("unknown field `{}` on variant `{}`", name, variant.name),
)
.with_span(tree.span),
);
}
}
}
fn check_children(tree: &ParseTree, variant: &VariantSchema, out: &mut Vec<Diagnostic>) {
for i in 0..tree.children.len() {
let (name, _) = &tree.children[i];
if tree.children[..i].iter().any(|(n, _)| n == name) {
out.push(
Diagnostic::error(
codes::DUPLICATE_CHILD,
format!(
"child slot `{}` appears more than once on variant `{}`",
name, variant.name
),
)
.with_span(tree.span),
);
}
}
for c in &variant.children {
let count = tree
.child_slot(&c.name)
.map(<[ParseTree]>::len)
.unwrap_or(0);
match c.multiplicity {
Multiplicity::One => {
if count != 1 {
out.push(diag_arity(codes::ARITY_ONE, variant, c, count, tree.span));
}
}
Multiplicity::Optional => {
if count > 1 {
out.push(diag_arity(
codes::ARITY_OPTIONAL,
variant,
c,
count,
tree.span,
));
}
}
Multiplicity::Many => {
}
}
}
for (name, _) in &tree.children {
if variant.children.iter().any(|c| &c.name == name) {
continue;
}
if variant.fields.iter().any(|f| &f.name == name) {
out.push(
Diagnostic::error(
codes::FIELD_AS_CHILD,
format!(
"`{}` on variant `{}` is a payload field, not a child slot \
(move it under `fields`)",
name, variant.name
),
)
.with_span(tree.span),
);
} else {
out.push(
Diagnostic::error(
codes::UNKNOWN_CHILD,
format!(
"unknown child slot `{}` on variant `{}`",
name, variant.name
),
)
.with_span(tree.span),
);
}
}
}
fn diag_arity(
code: &'static str,
variant: &VariantSchema,
child: &ChildSchema,
count: usize,
span: Option<Span>,
) -> Diagnostic {
let expected = match child.multiplicity {
Multiplicity::One => "exactly one child",
Multiplicity::Optional => "at most one child",
Multiplicity::Many => "zero or more children",
};
Diagnostic::error(
code,
format!(
"child slot `{}` on variant `{}` expects {} but got {}",
child.name, variant.name, expected, count
),
)
.with_span(span)
}
pub(crate) fn nearest_candidates(query: &str, variants: &[VariantSchema], k: usize) -> Vec<String> {
let mut scored: Vec<(usize, &str)> = variants
.iter()
.map(|v| (levenshtein(query, &v.name), v.name.as_str()))
.collect();
scored.sort_by_key(|(d, name)| (*d, name.to_string()));
let cutoff = query.len().max(1);
scored
.into_iter()
.filter(|(d, _)| *d <= cutoff)
.take(k)
.map(|(_, n)| n.to_string())
.collect()
}
fn levenshtein(a: &str, b: &str) -> usize {
let a: Vec<char> = a.chars().collect();
let b: Vec<char> = b.chars().collect();
let (m, n) = (a.len(), b.len());
if m == 0 {
return n;
}
if n == 0 {
return m;
}
let mut prev: Vec<usize> = (0..=n).collect();
let mut curr: Vec<usize> = vec![0; n + 1];
for i in 1..=m {
curr[0] = i;
for j in 1..=n {
let cost = if a[i - 1].eq_ignore_ascii_case(&b[j - 1]) {
0
} else {
1
};
curr[j] = (curr[j - 1] + 1).min(prev[j] + 1).min(prev[j - 1] + cost);
}
std::mem::swap(&mut prev, &mut curr);
}
prev[n]
}
pub fn build_field<T>(tree: &ParseTree, name: &str) -> Result<T, BuildError>
where
T: serde::de::DeserializeOwned + std::str::FromStr,
<T as std::str::FromStr>::Err: std::fmt::Display,
{
match tree.field(name) {
Some(RawValue::Json(v)) => serde_json::from_value(v.clone()).map_err(|e| {
BuildError::single(
Diagnostic::error(codes::FIELD_TYPE, format!("field `{name}`: {e}"))
.with_span(tree.span),
)
}),
Some(RawValue::Text(s)) => s.parse::<T>().map_err(|e| {
BuildError::single(
Diagnostic::error(codes::FIELD_TYPE, format!("field `{name}`: {e}"))
.with_span(tree.span),
)
}),
None => Err(BuildError::single(
Diagnostic::error(
codes::MISSING_FIELD,
format!("missing required field `{name}`"),
)
.with_span(tree.span),
)),
}
}
pub fn field_text<'t>(tree: &'t ParseTree, name: &str) -> Result<&'t str, BuildError> {
match tree.field(name) {
Some(RawValue::Text(s)) => Ok(s),
Some(RawValue::Json(_)) => Err(BuildError::single(
Diagnostic::error(
codes::FIELD_TYPE,
format!("field `{name}`: expected a text production, found JSON"),
)
.with_span(tree.span),
)),
None => Err(BuildError::single(
Diagnostic::error(
codes::MISSING_FIELD,
format!("missing required field `{name}`"),
)
.with_span(tree.span),
)),
}
}
pub fn build_child_one<T: DslBuild>(
tree: &ParseTree,
name: &str,
ids: &IdGen,
) -> Result<T, BuildError> {
let slot = tree.child_slot(name).unwrap_or(&[]);
if slot.len() != 1 {
return Err(BuildError::single(
Diagnostic::error(
codes::ARITY_ONE,
format!(
"child slot `{name}` expects exactly one child but got {}",
slot.len()
),
)
.with_span(tree.span),
));
}
T::from_parse_tree(&slot[0], ids)
}
pub fn build_child_optional<T: DslBuild>(
tree: &ParseTree,
name: &str,
ids: &IdGen,
) -> Result<Option<T>, BuildError> {
let slot = tree.child_slot(name).unwrap_or(&[]);
match slot.len() {
0 => Ok(None),
1 => Ok(Some(T::from_parse_tree(&slot[0], ids)?)),
n => Err(BuildError::single(
Diagnostic::error(
codes::ARITY_OPTIONAL,
format!("child slot `{name}` expects at most one child but got {n}"),
)
.with_span(tree.span),
)),
}
}
pub fn build_child_many<T: DslBuild>(
tree: &ParseTree,
name: &str,
ids: &IdGen,
) -> Result<Vec<T>, BuildError> {
let slot = tree.child_slot(name).unwrap_or(&[]);
let mut out = Vec::with_capacity(slot.len());
let mut diags = Vec::new();
for child in slot {
match T::from_parse_tree(child, ids) {
Ok(v) => out.push(v),
Err(mut e) => diags.append(&mut e.diagnostics),
}
}
if diags.is_empty() {
Ok(out)
} else {
Err(BuildError::new(diags))
}
}
#[cfg(test)]
mod tests {
use super::*;
use dsl_kit_schema::{ChildSchema, FieldSchema, Multiplicity, NodeSchema, VariantSchema};
fn schema_add_lit() -> NodeSchema {
NodeSchema {
name: "Expr".into(),
variants: vec![
VariantSchema {
name: "Lit".into(),
fields: vec![FieldSchema {
name: "value".into(),
ty: "i64".into(),
}],
children: vec![],
},
VariantSchema {
name: "Add".into(),
fields: vec![],
children: vec![
ChildSchema {
name: "lhs".into(),
multiplicity: Multiplicity::One,
},
ChildSchema {
name: "rhs".into(),
multiplicity: Multiplicity::One,
},
],
},
VariantSchema {
name: "Let".into(),
fields: vec![FieldSchema {
name: "name".into(),
ty: "String".into(),
}],
children: vec![
ChildSchema {
name: "value".into(),
multiplicity: Multiplicity::One,
},
ChildSchema {
name: "body".into(),
multiplicity: Multiplicity::One,
},
],
},
],
}
}
fn lit(v: i64) -> ParseTree {
let mut t = ParseTree::new("Lit");
t.fields.push(("value".into(), RawValue::Json(json!(v))));
t
}
#[test]
fn ok_lit() {
let schema = schema_add_lit();
assert!(check_conformance(&lit(1), &schema).is_empty());
}
#[test]
fn ok_add_with_two_children() {
let schema = schema_add_lit();
let mut add = ParseTree::new("Add");
add.children.push(("lhs".into(), vec![lit(1)]));
add.children.push(("rhs".into(), vec![lit(2)]));
assert!(check_conformance(&add, &schema).is_empty());
}
#[test]
fn unknown_variant_lists_candidates() {
let schema = schema_add_lit();
let tree = ParseTree::new("Aad"); let diags = check_conformance(&tree, &schema);
assert_eq!(diags.len(), 1);
assert_eq!(diags[0].code, codes::UNKNOWN_VARIANT);
assert!(
diags[0].message.contains("Add"),
"expected Add to appear as a candidate; got: {}",
diags[0].message
);
}
#[test]
fn missing_field_is_reported() {
let schema = schema_add_lit();
let tree = ParseTree::new("Lit"); let diags = check_conformance(&tree, &schema);
assert_eq!(diags.len(), 1);
assert_eq!(diags[0].code, codes::MISSING_FIELD);
assert!(diags[0].message.contains("value"));
}
#[test]
fn unknown_field_is_reported() {
let schema = schema_add_lit();
let mut tree = lit(3);
tree.fields.push(("extra".into(), RawValue::Json(json!(0))));
let diags = check_conformance(&tree, &schema);
assert_eq!(diags.len(), 1);
assert_eq!(diags[0].code, codes::UNKNOWN_FIELD);
}
#[test]
fn field_and_child_slot_swapped_reports_structural_codes() {
let schema = schema_add_lit();
let mut swap1 = ParseTree::new("Add");
swap1.fields.push(("lhs".into(), RawValue::Json(json!(0))));
swap1.children.push(("rhs".into(), vec![lit(1)]));
let diags = check_conformance(&swap1, &schema);
assert!(diags.iter().any(|d| d.code == codes::CHILD_AS_FIELD));
assert!(diags.iter().any(|d| d.code == codes::ARITY_ONE));
let mut swap2 = ParseTree::new("Let");
swap2
.children
.push(("name".into(), vec![ParseTree::new("Lit")]));
swap2.children.push(("value".into(), vec![lit(1)]));
swap2.children.push(("body".into(), vec![lit(2)]));
let diags = check_conformance(&swap2, &schema);
assert!(diags.iter().any(|d| d.code == codes::FIELD_AS_CHILD));
assert!(diags.iter().any(|d| d.code == codes::MISSING_FIELD));
}
#[test]
fn arity_one_reports_wrong_count() {
let schema = schema_add_lit();
let mut add = ParseTree::new("Add");
add.children.push(("lhs".into(), vec![lit(1), lit(2)])); add.children.push(("rhs".into(), vec![lit(3)]));
let diags = check_conformance(&add, &schema);
assert_eq!(diags.len(), 1);
assert_eq!(diags[0].code, codes::ARITY_ONE);
assert!(diags[0].message.contains("lhs"));
}
#[test]
fn duplicate_field_and_child_reported() {
let schema = schema_add_lit();
let mut t = ParseTree::new("Lit");
t.fields.push(("value".into(), RawValue::Json(json!(1))));
t.fields.push(("value".into(), RawValue::Json(json!(2))));
let diags = check_conformance(&t, &schema);
assert!(diags.iter().any(|d| d.code == codes::DUPLICATE_FIELD));
let mut a = ParseTree::new("Add");
a.children.push(("lhs".into(), vec![lit(1)]));
a.children.push(("lhs".into(), vec![lit(2)]));
a.children.push(("rhs".into(), vec![lit(3)]));
let diags = check_conformance(&a, &schema);
assert!(diags.iter().any(|d| d.code == codes::DUPLICATE_CHILD));
}
#[test]
fn diagnostic_json_shape() {
let diag = Diagnostic::error("x::y", "boom").with_span(Some(Span::new(3, 7)));
let v = diag.to_json();
assert_eq!(v["severity"], "error");
assert_eq!(v["code"], "x::y");
assert_eq!(v["message"], "boom");
assert_eq!(v["location"]["kind"], "span");
assert_eq!(v["location"]["start"], 3);
assert_eq!(v["location"]["end"], 7);
}
#[test]
fn build_error_display_lists_all() {
let err = BuildError::new(vec![
Diagnostic::error("a::b", "one"),
Diagnostic::error("c::d", "two"),
]);
let s = format!("{err}");
assert!(s.contains("a::b: one"));
assert!(s.contains("c::d: two"));
}
}