konjure_lang/

program.rs

//! Declaration resolution and module linking. Bodies remain source-preserving for debugging.
use crate::ast::*;
use crate::parser::{Token, parse, tokenize};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};

pub(crate) const MAIN: &str = "main";
pub(crate) const BUILTIN: &str = "builtin";

/// A declaration available to editor navigation and generated reference pages.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Symbol {
    /// Unqualified declaration or method name.
    pub name: String,
    /// Module-qualified identity used by editor navigation.
    pub qualified_name: String,
    /// Declaration category, such as class, function, field, or system.
    pub kind: String,
    /// Definition source range in UTF-8 bytes.
    pub span: Span,
    /// Human-readable language declaration signature.
    pub signature: String,
    /// Whether other supplied modules may access this declaration.
    pub exported: bool,
}
/// A callable component method, used by host action controls.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MethodSymbol {
    /// Canonical component class key in snapshots.
    pub class: String,
    /// Method name for `Machine::invoke_entity`.
    pub name: String,
    /// Explicit arguments, excluding implicit `self`.
    pub parameter_count: usize,
    /// Method definition source location.
    pub span: Span,
}
/// Source-level semantic metadata for a program whose declarations and bodies are checked.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ProgramMetadata {
    /// Callable component methods, including their explicit arity.
    pub methods: Vec<MethodSymbol>,
    /// Class, field, function, trait, and system declarations.
    pub symbols: Vec<Symbol>,
    /// Source tokens across all linked modules, including comments.
    pub tokens: Vec<Token>,
    /// Modules in dependency initialization order.
    pub modules: Vec<String>,
    /// Checked expression references; lexical locals never resolve to global values by spelling.
    pub references: Vec<ExpressionReference>,
}
/// Compiler-resolved source identity for an editor inspector. Inspectors do not evaluate source.
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ExpressionReference {
    /// Exact expression source range.
    pub span: Span,
    /// Canonical checked type.
    pub ty: Type,
    /// Expression category: global, local, constructor, method, or expression.
    pub kind: String,
    /// Canonical declaration or global binding identity, when one is resolved.
    pub identity: Option<String>,
    /// Whether identity names a stored global value that can be inspected without evaluation.
    pub inspectable: bool,
    /// A typed path to accepted snapshot storage, never an expression to execute.
    pub target: Option<crate::inspection::InspectionTarget>,
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Module {
    pub classes: BTreeMap<String, Class>,
    pub enums: BTreeMap<String, Enum>,
    pub functions: BTreeMap<String, Function>,
    pub traits: BTreeMap<String, Trait>,
    pub imports: BTreeSet<String>,
    pub exports: BTreeSet<String>,
    pub statements: Vec<Stmt>,
}
/// Linked program. It owns all source text; imports never access the filesystem or network.
#[derive(Clone, Debug)]
pub struct Program {
    pub(crate) modules: BTreeMap<String, Module>,
    pub(crate) methods: BTreeMap<String, BTreeMap<String, Function>>,
    pub(crate) implementations: BTreeSet<(String, String)>,
    pub(crate) systems: Vec<(String, System)>,
    pub(crate) order: Vec<String>,
    pub(crate) sources: BTreeMap<String, String>,
    pub(crate) native_signatures: BTreeMap<String, (Vec<Type>, Type)>,
    pub(crate) binding_types: BTreeMap<(String, usize, usize), Type>,
    pub(crate) mutating_methods: BTreeSet<(String, String)>,
    pub(crate) expression_types: BTreeMap<(String, usize, usize), Type>,
    pub(crate) method_receivers: BTreeMap<(String, usize, usize), Type>,
    pub(crate) metadata: ProgramMetadata,
}
impl Program {
    /// Editor symbols, highlight tokens, and linked source modules.
    pub fn metadata(&self) -> &ProgramMetadata {
        &self.metadata
    }
    /// Original UTF-8 source, keyed by module name (`main` and `builtin` are reserved).
    pub fn sources(&self) -> &BTreeMap<String, String> {
        &self.sources
    }
    pub(crate) fn key(module: &str, name: &str) -> String {
        if module == MAIN || module == BUILTIN {
            name.to_owned()
        } else {
            format!("{module}.{name}")
        }
    }
    pub(crate) fn resolve(
        &self,
        module: &str,
        name: &str,
        span: &Span,
    ) -> Result<(String, String), Diagnostic> {
        if let Some((prefix, local)) = name.rsplit_once('.') {
            let current = &self.modules[module];
            if prefix != module && prefix != BUILTIN && !current.imports.contains(prefix) {
                return Err(Diagnostic::new(
                    "unknown_module",
                    format!("module `{prefix}` is not imported"),
                    span.clone(),
                ));
            }
            let target = self.modules.get(prefix).ok_or_else(|| {
                Diagnostic::new(
                    "unknown_module",
                    format!("unknown module `{prefix}`"),
                    span.clone(),
                )
            })?;
            if prefix != module && prefix != BUILTIN && !target.exports.contains(local) {
                return Err(Diagnostic::new(
                    "private_name",
                    format!("`{local}` is not exported by `{prefix}`"),
                    span.clone(),
                ));
            }
            return Ok((prefix.to_owned(), local.to_owned()));
        }
        let m = &self.modules[module];
        if m.classes.contains_key(name)
            || m.enums.contains_key(name)
            || m.functions.contains_key(name)
            || m.traits.contains_key(name)
        {
            return Ok((module.to_owned(), name.to_owned()));
        }
        let b = &self.modules[BUILTIN];
        if b.classes.contains_key(name)
            || b.enums.contains_key(name)
            || b.functions.contains_key(name)
            || b.traits.contains_key(name)
        {
            return Ok((BUILTIN.to_owned(), name.to_owned()));
        }
        Ok((module.to_owned(), name.to_owned()))
    }
    pub(crate) fn class(
        &self,
        module: &str,
        name: &str,
        span: &Span,
    ) -> Result<(String, &Class), Diagnostic> {
        let (m, n) = self.resolve(module, name, span)?;
        let class = self.modules[&m].classes.get(&n).ok_or_else(|| {
            Diagnostic::new(
                "unknown_class",
                format!("unknown class `{name}`"),
                span.clone(),
            )
        })?;
        Ok((m, class))
    }
    pub(crate) fn class_by_key(&self, key: &str) -> Option<(&str, &Class)> {
        self.modules.iter().find_map(|(m, module)| {
            module
                .classes
                .values()
                .find(|c| Self::key(m, &c.name) == key)
                .map(|c| (m.as_str(), c))
        })
    }
    pub(crate) fn enum_by_key(&self, key: &str) -> Option<(&str, &Enum)> {
        self.modules.iter().find_map(|(module, declarations)| {
            declarations
                .enums
                .values()
                .find(|value| Self::key(module, &value.name) == key)
                .map(|value| (module.as_str(), value))
        })
    }
    pub(crate) fn variant(
        &self,
        module: &str,
        name: &str,
        span: &Span,
    ) -> Result<Option<(Type, String, Vec<Type>)>, Diagnostic> {
        let Some((owner, case)) = name.rsplit_once('.') else {
            return Ok(None);
        };
        let (target, local) = self.resolve(module, owner, span)?;
        let Some(declaration) = self.modules[&target].enums.get(&local) else {
            return Ok(None);
        };
        let variant = declaration
            .cases
            .iter()
            .find(|variant| variant.name == case)
            .ok_or_else(|| {
                Diagnostic::new(
                    "unknown_case",
                    format!("{owner} has no case {case}"),
                    span.clone(),
                )
            })?;
        let payload = variant
            .payload
            .iter()
            .map(|ty| self.canonical_type(&target, ty, span))
            .collect::<Result<_, _>>()?;
        Ok(Some((
            Type::named(Self::key(&target, &local)),
            case.into(),
            payload,
        )))
    }
    pub(crate) fn canonical_type(
        &self,
        module: &str,
        ty: &Type,
        span: &Span,
    ) -> Result<Type, Diagnostic> {
        match ty {
            Type::Applied { name, arguments } => Ok(Type::Applied {
                name: name.clone(),
                arguments: arguments
                    .iter()
                    .map(|ty| self.canonical_type(module, ty, span))
                    .collect::<Result<_, _>>()?,
            }),
            Type::Function {
                parameters,
                returns,
            } => Ok(Type::function(
                parameters
                    .iter()
                    .map(|ty| self.canonical_type(module, ty, span))
                    .collect::<Result<_, _>>()?,
                self.canonical_type(module, returns, span)?,
            )),
            Type::ComponentReference(inner) => Ok(Type::ComponentReference(Box::new(
                self.canonical_type(module, inner, span)?,
            ))),
            Type::Tensor(inner) => {
                let inner = self.canonical_type(module, inner, span)?;
                if crate::data::dtype(&inner).is_none() {
                    return Err(Diagnostic::new(
                        "invalid_dtype",
                        "Tensor[T] requires a numeric dtype",
                        span.clone(),
                    ));
                }
                Ok(Type::Tensor(Box::new(inner)))
            }
            Type::List(inner) => Ok(Type::List(Box::new(
                self.canonical_type(module, inner, span)?,
            ))),
            Type::Named(name)
                if crate::data::is_primitive(name) || matches!(name.as_str(), "Any" | "List") =>
            {
                Ok(Type::named(name))
            }
            Type::Named(name) => {
                // Checked signatures can carry private nominal types through an
                // exported function. Their canonical identity is already resolved.
                if name.contains('.')
                    && (self.class_by_key(name).is_some()
                        || self.enum_by_key(name).is_some()
                        || self.modules.iter().any(|(m, declarations)| {
                            declarations
                                .traits
                                .contains_key(name.strip_prefix(&format!("{m}.")).unwrap_or(""))
                        }))
                {
                    return Ok(ty.clone());
                }
                let (m, n) = self.resolve(module, name, span)?;
                Ok(Type::named(Self::key(&m, &n)))
            }
        }
    }
    pub(crate) fn typed_builtin_signature(
        &self,
        name: &str,
        ty: &Type,
        span: &Span,
    ) -> Result<Type, Diagnostic> {
        if name == "tensor" {
            if crate::data::dtype(ty).is_none() {
                return Err(Diagnostic::new(
                    "invalid_dtype",
                    "tensor[T] requires a numeric dtype",
                    span.clone(),
                ));
            }
            return Ok(Type::function(
                vec![Type::List(Box::new(ty.clone())), crate::data::shape_type()],
                crate::data::result_type(crate::data::tensor_type(ty.clone())),
            ));
        }
        let Type::Named(key) = ty else {
            return Err(Diagnostic::new(
                "unknown_query_type",
                "ECS type argument must be a class or trait",
                span.clone(),
            ));
        };
        let concrete = self.class_by_key(key).is_some();
        let contract = self.modules.iter().any(|(module, declarations)| {
            declarations
                .traits
                .keys()
                .any(|local| Self::key(module, local) == *key)
        });
        if !matches!(name, "get" | "has" | "query" | "bind") {
            return Err(Diagnostic::new(
                "invalid_type_argument",
                "only get, has, query, and bind accept a type argument",
                span.clone(),
            ));
        }
        if !concrete && (name != "query" || !contract) {
            return Err(Diagnostic::new(
                "unknown_query_type",
                format!(
                    "{name}<T> requires {}",
                    if name == "query" {
                        "a class or trait"
                    } else {
                        "a concrete class"
                    }
                ),
                span.clone(),
            ));
        }
        let parameters = if name == "query" {
            vec![]
        } else {
            vec![Type::named("Entity")]
        };
        let returns = match name {
            "get" => ty.clone(),
            "has" => Type::named("Bool"),
            "bind" => Type::ComponentReference(Box::new(ty.clone())),
            _ => Type::List(Box::new(Type::named("Entity"))),
        };
        Ok(Type::function(parameters, returns))
    }
    fn same_signature(&self, actual: &Function, required: &Function) -> bool {
        actual.parameters.len() == required.parameters.len()
            && actual
                .parameters
                .iter()
                .zip(&required.parameters)
                .all(|(a, b)| {
                    self.canonical_type(&actual.span.module, &a.ty, &a.span)
                        .ok()
                        == self
                            .canonical_type(&required.span.module, &b.ty, &b.span)
                            .ok()
                })
            && self
                .canonical_type(&actual.span.module, &actual.returns, &actual.span)
                .ok()
                == self
                    .canonical_type(&required.span.module, &required.returns, &required.span)
                    .ok()
    }
    pub(crate) fn query_classes(
        &self,
        module: &str,
        name: &str,
        span: &Span,
    ) -> Result<Vec<String>, Diagnostic> {
        let (m, n) = self.resolve(module, name, span)?;
        let key = Self::key(&m, &n);
        if self.modules[&m].classes.contains_key(&n) {
            return Ok(vec![key]);
        }
        if self.modules[&m].traits.contains_key(&n) {
            return Ok(self
                .implementations
                .iter()
                .filter_map(|(class, t)| (t == &key).then_some(class.clone()))
                .collect());
        }
        Err(Diagnostic::new(
            "unknown_query_type",
            format!("`{name}` is not a class or trait"),
            span.clone(),
        ))
    }
    pub(crate) fn has_type(&self, module: &str, ty: &Type, span: &Span) -> Result<(), Diagnostic> {
        match ty {
            Type::Applied { name, arguments } => {
                let arity = match name.as_str() {
                    "Res" => 2,
                    "Opt" => 1,
                    _ => {
                        return Err(Diagnostic::new(
                            "unknown_type",
                            format!("unknown generic type {name}"),
                            span.clone(),
                        ));
                    }
                };
                if arguments.len() != arity {
                    return Err(Diagnostic::new(
                        "type_arity",
                        format!("{name} requires {arity} type arguments"),
                        span.clone(),
                    ));
                }
                for argument in arguments {
                    self.has_type(module, argument, span)?;
                }
                Ok(())
            }
            Type::Tensor(inner) => {
                if crate::data::dtype(inner).is_none() {
                    return Err(Diagnostic::new(
                        "invalid_dtype",
                        "Tensor[T] requires a numeric dtype",
                        span.clone(),
                    ));
                }
                Ok(())
            }
            Type::List(inner) => self.has_type(module, inner, span),
            Type::ComponentReference(inner) => {
                let Type::Named(name) = inner.as_ref() else {
                    return Err(Diagnostic::new(
                        "unknown_type",
                        "ComponentReference[T] requires a concrete class",
                        span.clone(),
                    ));
                };
                self.class(module, name, span).map(|_| ())
            }
            Type::Function {
                parameters,
                returns,
            } => {
                for ty in parameters.iter().chain(std::iter::once(returns.as_ref())) {
                    self.has_type(module, ty, span)?;
                }
                Ok(())
            }
            Type::Named(name)
                if crate::data::is_primitive(name) || matches!(name.as_str(), "Any" | "List") =>
            {
                Ok(())
            }
            Type::Named(name) => {
                let (m, n) = self.resolve(module, name, span)?;
                if self.modules[&m].classes.contains_key(&n)
                    || self.modules[&m].enums.contains_key(&n)
                    || self.modules[&m].traits.contains_key(&n)
                {
                    Ok(())
                } else {
                    Err(Diagnostic::new(
                        "unknown_type",
                        format!("unknown type `{name}`"),
                        span.clone(),
                    ))
                }
            }
        }
    }
}
pub(crate) fn type_text(ty: &Type) -> String {
    match ty {
        Type::Applied { name, arguments } => format!(
            "{name}[{}]",
            arguments
                .iter()
                .map(type_text)
                .collect::<Vec<_>>()
                .join(", ")
        ),
        Type::Named(n) => n.clone(),
        Type::Tensor(t) => format!("Tensor[{}]", type_text(t)),
        Type::List(t) => format!("List[{}]", type_text(t)),
        Type::ComponentReference(t) => format!("ComponentReference[{}]", type_text(t)),
        Type::Function {
            parameters,
            returns,
        } => format!(
            "func({}) -> {}",
            parameters
                .iter()
                .map(type_text)
                .collect::<Vec<_>>()
                .join(", "),
            type_text(returns)
        ),
    }
}
pub(crate) fn function_text(f: &Function) -> String {
    format!(
        "func {}({}) -> {}",
        f.name,
        f.parameters
            .iter()
            .map(|p| format!("{}: {}", p.name, type_text(&p.ty)))
            .collect::<Vec<_>>()
            .join(", "),
        type_text(&f.returns)
    )
}
fn symbol(
    module: &str,
    name: &str,
    kind: &str,
    span: &Span,
    signature: String,
    exports: &BTreeSet<String>,
) -> Symbol {
    Symbol {
        name: name.into(),
        qualified_name: format!("{module}.{name}"),
        kind: kind.into(),
        span: span.clone(),
        signature,
        exported: module == MAIN || module == BUILTIN || exports.contains(name),
    }
}

fn pure_default(expr: &Expr) -> bool {
    match &expr.kind {
        ExprKind::Assign { .. } => false,
        ExprKind::TensorLiteral { values, .. } => values.iter().all(pure_default),
        ExprKind::Match { value, arms } => {
            pure_default(value) && arms.iter().all(|arm| pure_default(&arm.value))
        }
        ExprKind::Propagate(value) => pure_default(value),
        ExprKind::TypedMethod { object, .. } => pure_default(object),
        ExprKind::TypedLiteral { value, .. } => pure_default(value),
        ExprKind::Number(_) | ExprKind::Bool(_) | ExprKind::Text(_) | ExprKind::Unit => true,
        ExprKind::Name(_) => true,
        ExprKind::List(values) => values.iter().all(pure_default),
        ExprKind::Record { fields, .. } => fields.values().all(pure_default),
        ExprKind::Unary { value, .. } => pure_default(value),
        ExprKind::Binary { left, right, .. } => pure_default(left) && pure_default(right),
        ExprKind::Field { object, .. } => pure_default(object),
        ExprKind::Index { object, indices } => {
            pure_default(object)
                && indices.iter().all(|index| match index {
                    IndexExpr::Index(e) => pure_default(e),
                    IndexExpr::Slice { start, stop, step } => [start, stop, step]
                        .into_iter()
                        .flatten()
                        .all(|expr| pure_default(expr)),
                    IndexExpr::NewAxis | IndexExpr::Ellipsis => true,
                })
        }
        ExprKind::TypedFunction { .. } => true,
        ExprKind::TypedCall {
            name, arguments, ..
        } => {
            matches!(
                name.as_str(),
                "tensor" | "convert" | "builtin.tensor" | "builtin.convert"
            ) && arguments.iter().all(pure_default)
        }
        ExprKind::Call { callee, arguments } => {
            let name = match &callee.kind {
                ExprKind::Name(n) => Some(n.as_str()),
                ExprKind::Field { object, field } if matches!(&object.kind,ExprKind::Name(n) if n=="builtin") => {
                    Some(field.as_str())
                }
                _ => None,
            };
            name.is_some_and(|n| {
                matches!(
                    n,
                    "sin"
                        | "cos"
                        | "sqrt"
                        | "abs"
                        | "floor"
                        | "ceil"
                        | "min"
                        | "max"
                        | "clamp"
                        | "pow"
                        | "len"
                        | "append"
                        | "range"
                )
            }) && arguments.iter().all(pure_default)
        }
    }
}

/// Parse declarations, resolve explicit module imports, and validate type/trait contracts.
///
/// All authored declarations and bodies are statically checked before initialization.
/// Runtime value and resource checks preserve transactional execution.
///
/// # Errors
/// Returns source-linked syntax, declaration, module, or trait-contract diagnostics.
pub fn compile(
    source: &str,
    supplied: &BTreeMap<String, String>,
) -> Result<Program, Vec<Diagnostic>> {
    compile_with_registry(source, supplied, &crate::NativeRegistry::default())
}

/// Compile with explicit pure host signatures available to the static checker.
/// The machine must receive a registry with these same signatures.
/// # Errors
/// Returns source-linked syntax, declaration, type, or trait diagnostics.
pub fn compile_with_registry(
    source: &str,
    supplied: &BTreeMap<String, String>,
    registry: &crate::NativeRegistry,
) -> Result<Program, Vec<Diagnostic>> {
    let mut sources = BTreeMap::from([
        (MAIN.to_owned(), source.to_owned()),
        (BUILTIN.to_owned(), crate::catalog::PRELUDE.to_owned()),
    ]);
    let mut parsed = BTreeMap::<String, Vec<Item>>::new();
    let mut order = Vec::new();
    let mut visiting = BTreeSet::new();
    let mut errors = Vec::new();
    fn load(
        name: &str,
        supplied: &BTreeMap<String, String>,
        sources: &mut BTreeMap<String, String>,
        parsed: &mut BTreeMap<String, Vec<Item>>,
        order: &mut Vec<String>,
        visiting: &mut BTreeSet<String>,
        errors: &mut Vec<Diagnostic>,
    ) {
        if parsed.contains_key(name) {
            return;
        }
        if order.len() + visiting.len() >= 64 {
            errors.push(Diagnostic::new(
                "module_limit",
                "program exceeds 64 modules",
                Span::new(name, 0, 0),
            ));
            return;
        }
        if !visiting.insert(name.to_owned()) {
            errors.push(Diagnostic::new(
                "cyclic_import",
                format!("cyclic import of `{name}`"),
                Span::new(name, 0, 0),
            ));
            return;
        }
        let Some(source) = sources
            .get(name)
            .cloned()
            .or_else(|| supplied.get(name).cloned())
        else {
            errors.push(Diagnostic::new(
                "missing_module",
                format!("module `{name}` was not supplied"),
                Span::new(name, 0, 0),
            ));
            visiting.remove(name);
            return;
        };
        sources.insert(name.to_owned(), source.clone());
        match parse(&source, name) {
            Ok(items) => {
                for item in &items {
                    if let Item::Import { module, span } = item {
                        if module == MAIN {
                            errors.push(Diagnostic::new(
                                "reserved_module",
                                "cannot import reserved entry module `main`",
                                span.clone(),
                            ));
                            continue;
                        }
                        load(module, supplied, sources, parsed, order, visiting, errors);
                    }
                }
                parsed.insert(name.to_owned(), items);
                order.push(name.to_owned());
            }
            Err(mut diagnostics) => errors.append(&mut diagnostics),
        }
        visiting.remove(name);
    }
    load(
        BUILTIN,
        supplied,
        &mut sources,
        &mut parsed,
        &mut order,
        &mut visiting,
        &mut errors,
    );
    load(
        MAIN,
        supplied,
        &mut sources,
        &mut parsed,
        &mut order,
        &mut visiting,
        &mut errors,
    );
    if !errors.is_empty() {
        return Err(errors);
    }
    let mut program = Program {
        modules: BTreeMap::new(),
        methods: BTreeMap::new(),
        implementations: BTreeSet::new(),
        systems: Vec::new(),
        order,
        sources,
        native_signatures: registry.signatures(),
        binding_types: BTreeMap::new(),
        mutating_methods: BTreeSet::new(),
        expression_types: BTreeMap::new(),
        method_receivers: BTreeMap::new(),
        metadata: ProgramMetadata {
            methods: Vec::new(),
            symbols: Vec::new(),
            tokens: Vec::new(),
            modules: Vec::new(),
            references: Vec::new(),
        },
    };
    let mut implementations = Vec::new();
    for module_name in &program.order {
        let mut module = Module::default();
        if module_name == BUILTIN {
            module.enums.insert(
                "DataError".into(),
                Enum {
                    name: "DataError".into(),
                    cases: konjure_sdk::data::DataError::VARIANTS
                        .iter()
                        .map(|case| EnumCase {
                            name: case.name.into(),
                            payload: vec![],
                            span: Span::new(BUILTIN, 0, 0),
                        })
                        .collect(),
                    span: Span::new(BUILTIN, 0, 0),
                },
            );
        }
        let mut names = BTreeSet::new();
        for item in &parsed[module_name] {
            let named = match item {
                Item::Class(c) => Some((&c.name, &c.span)),
                Item::Enum(e) => Some((&e.name, &e.span)),
                Item::Function(f) => Some((&f.name, &f.span)),
                Item::Trait(t) => Some((&t.name, &t.span)),
                Item::System(s) => Some((&s.name, &s.span)),
                _ => None,
            };
            if let Some((name, span)) = named
                && !names.insert(name.clone())
            {
                errors.push(Diagnostic::new(
                    "duplicate_name",
                    format!("duplicate declaration `{name}`"),
                    span.clone(),
                ));
            }
            match item {
                Item::Enum(e) => {
                    let mut cases = BTreeSet::new();
                    for case in &e.cases {
                        if !cases.insert(&case.name) {
                            errors.push(Diagnostic::new(
                                "duplicate_case",
                                format!("duplicate enum case {}", case.name),
                                case.span.clone(),
                            ));
                        }
                    }
                    module.enums.insert(e.name.clone(), e.clone());
                }
                Item::Class(c) => {
                    let mut fields = BTreeSet::new();
                    for f in &c.fields {
                        if !fields.insert(&f.name) {
                            errors.push(Diagnostic::new(
                                "duplicate_field",
                                format!("duplicate field `{}`", f.name),
                                f.span.clone(),
                            ));
                        }
                    }
                    implementations.push((
                        module_name.clone(),
                        Implementation {
                            trait_name: None,
                            class: c.name.clone(),
                            methods: c.methods.clone(),
                            span: c.span.clone(),
                        },
                    ));
                    module.classes.insert(c.name.clone(), c.clone());
                }
                Item::Function(f) => {
                    module.functions.insert(f.name.clone(), f.clone());
                }
                Item::Trait(t) => {
                    module.traits.insert(t.name.clone(), t.clone());
                }
                Item::System(s) => program.systems.push((module_name.clone(), s.clone())),
                Item::Implementation(i) => implementations.push((module_name.clone(), i.clone())),
                Item::Import { module: m, .. } => {
                    module.imports.insert(m.clone());
                }
                Item::Export { name, .. } => {
                    module.exports.insert(name.clone());
                }
                Item::Statement(s) => module.statements.push(s.clone()),
            }
        }
        for item in &parsed[module_name] {
            if let Item::Export { name, span } = item
                && !names.contains(name)
                && !module
                    .statements
                    .iter()
                    .any(|s| matches!(&s.kind,StmtKind::Let{name:n,..} if n==name))
            {
                errors.push(Diagnostic::new(
                    "unknown_export",
                    format!("cannot export undefined name `{name}`"),
                    span.clone(),
                ));
            }
        }
        program.modules.insert(module_name.clone(), module);
    }
    for (m, module) in &program.modules {
        if m != BUILTIN {
            for item in &parsed[m] {
                let named = match item {
                    Item::Class(c) => Some((&c.name, &c.span)),
                    Item::Enum(e) => Some((&e.name, &e.span)),
                    Item::Function(f) => Some((&f.name, &f.span)),
                    Item::Trait(t) => Some((&t.name, &t.span)),
                    _ => None,
                };
                if let Some((name, span)) = named {
                    let builtin = &program.modules[BUILTIN];
                    if builtin.classes.contains_key(name)
                        || builtin.enums.contains_key(name)
                        || builtin.traits.contains_key(name)
                        || crate::native::is_builtin(name)
                        || crate::data::is_primitive(name)
                        || matches!(
                            name.as_str(),
                            "Any"
                                | "List"
                                | "Tensor"
                                | "ComponentReference"
                                | "Res"
                                | "Opt"
                                | "Never"
                                | "Ok"
                                | "Err"
                                | "Some"
                                | "None"
                        )
                    {
                        errors.push(Diagnostic::new(
                            "reserved_name",
                            format!("`{name}` is provided by the builtin namespace"),
                            span.clone(),
                        ));
                    }
                }
            }
        }
        let validate_function = |f: &Function, errors: &mut Vec<Diagnostic>| {
            let mut parameters = BTreeSet::new();
            for p in &f.parameters {
                if !parameters.insert(&p.name) {
                    errors.push(Diagnostic::new(
                        "duplicate_parameter",
                        format!("duplicate parameter `{}`", p.name),
                        p.span.clone(),
                    ));
                }
                if let Err(e) = program.has_type(m, &p.ty, &p.span) {
                    errors.push(e);
                }
            }
            if let Err(e) = program.has_type(m, &f.returns, &f.span) {
                errors.push(e);
            }
        };
        for f in module.functions.values() {
            validate_function(f, &mut errors);
        }
        for declaration in module.enums.values() {
            for case in &declaration.cases {
                for ty in &case.payload {
                    if let Err(error) = program.has_type(m, ty, &case.span) {
                        errors.push(error);
                    }
                }
            }
        }
        for t in module.traits.values() {
            let mut methods = BTreeSet::new();
            for f in &t.methods {
                validate_function(f, &mut errors);
                if !methods.insert(&f.name) {
                    errors.push(Diagnostic::new(
                        "duplicate_method",
                        format!("duplicate trait method `{}`", f.name),
                        f.span.clone(),
                    ));
                }
            }
        }
        for c in module.classes.values() {
            for field in &c.fields {
                if let Some(default) = &field.default
                    && !pure_default(default)
                {
                    errors.push(Diagnostic::new("impure_default","field defaults allow only constant values, constructors, and pure builtin expressions",default.span.clone()));
                }
                if let Err(e) = program.has_type(m, &field.ty, &field.span) {
                    errors.push(e);
                }
            }
        }
    }
    for (module, i) in implementations {
        let (class_module, class) = match program.class(&module, &i.class, &i.span) {
            Ok(c) => c,
            Err(e) => {
                errors.push(e);
                continue;
            }
        };
        let class_key = Program::key(&class_module, &class.name);
        if let Some(trait_name) = &i.trait_name {
            match program.resolve(&module, trait_name, &i.span) {
                Ok((tm, tn)) => {
                    if let Some(t) = program.modules[&tm].traits.get(&tn) {
                        for required in &t.methods {
                            match i.methods.iter().find(|f| f.name == required.name) {
                                Some(actual) if program.same_signature(actual, required) => {}
                                _ => errors.push(Diagnostic::new(
                                    "trait_contract",
                                    format!(
                                        "implementation of `{trait_name}` needs `{}`",
                                        function_text(required)
                                    ),
                                    i.span.clone(),
                                )),
                            }
                        }
                        for method in &i.methods {
                            if !t.methods.iter().any(|r| r.name == method.name) {
                                errors.push(Diagnostic::new(
                                    "trait_contract",
                                    format!(
                                        "`{}` is not a member of trait `{trait_name}`",
                                        method.name
                                    ),
                                    method.span.clone(),
                                ));
                            }
                        }
                        program
                            .implementations
                            .insert((class_key.clone(), Program::key(&tm, &tn)));
                    } else {
                        errors.push(Diagnostic::new(
                            "unknown_trait",
                            format!("unknown trait `{trait_name}`"),
                            i.span.clone(),
                        ));
                    }
                }
                Err(e) => errors.push(e),
            }
        }
        for method in &i.methods {
            let mut parameters = std::collections::BTreeSet::new();
            for parameter in &method.parameters {
                if parameter.name == "self" || !parameters.insert(&parameter.name) {
                    errors.push(Diagnostic::new(
                        "duplicate_parameter",
                        "method parameters must be unique and cannot redeclare implicit self",
                        parameter.span.clone(),
                    ));
                }
            }
            if let Err(e) = program.has_type(&module, &method.returns, &method.span) {
                errors.push(e);
            }
            for param in &method.parameters {
                if let Err(e) = program.has_type(&module, &param.ty, &param.span) {
                    errors.push(e);
                }
            }
        }
        let methods = program.methods.entry(class_key).or_default();
        for method in i.methods {
            if methods
                .insert(method.name.clone(), method.clone())
                .is_some()
            {
                errors.push(Diagnostic::new(
                    "duplicate_method",
                    format!("duplicate method `{}`", method.name),
                    method.span,
                ));
            }
        }
    }
    for (m, system) in &program.systems {
        if system.bindings.is_empty() {
            errors.push(Diagnostic::new(
                "system_query",
                "system needs at least one component binding",
                system.span.clone(),
            ));
        }
        let mut bindings = BTreeSet::new();
        let mut classes = BTreeSet::new();
        for binding in &system.bindings {
            if !bindings.insert(binding.name.clone())
                || matches!(binding.name.as_str(), "entity" | "time" | "tick" | "dt")
            {
                errors.push(Diagnostic::new(
                    "system_binding",
                    "component bindings must be unique and cannot use entity, time, tick, or dt",
                    binding.span.clone(),
                ));
            }
            let Type::Named(name) = &binding.ty else {
                errors.push(Diagnostic::new(
                    "system_query",
                    "component selector must name a class or trait",
                    binding.span.clone(),
                ));
                continue;
            };
            if let Err(e) = program.query_classes(m, name, &binding.span) {
                errors.push(e);
            }
            if system.bindings.len() > 1 {
                match program.class(m, name, &binding.span) {
                    Ok((module, class)) => {
                        if !classes.insert(Program::key(&module, &class.name)) {
                            errors.push(Diagnostic::new(
                                "system_alias",
                                "a join cannot bind the same component class twice",
                                binding.span.clone(),
                            ));
                        }
                    }
                    Err(e) => errors.push(e),
                }
            }
        }
        let mut callbacks = BTreeSet::new();
        for callback in &system.callbacks {
            if !callbacks.insert(callback.name.clone()) {
                errors.push(Diagnostic::new(
                    "duplicate_callback",
                    format!("duplicate system callback `{}`", callback.name),
                    callback.span.clone(),
                ));
            }
            let valid = (callback.returns == Type::named("Unit")
                || callback.returns == crate::data::result_type(Type::named("Unit")))
                && match callback.name.as_str() {
                    "init" | "done" => callback.parameters.is_empty(),
                    "frame" => {
                        callback.parameters.len() == 1
                            && callback.parameters[0].ty == Type::named("f64")
                    }
                    _ => false,
                };
            if !valid {
                errors.push(Diagnostic::new("lifecycle_signature", "system callbacks are init() -> Unit, frame(dt: Number) -> Unit, and done() -> Unit", callback.span.clone()));
            }
            for parameter in &callback.parameters {
                if bindings.contains(&parameter.name)
                    || matches!(parameter.name.as_str(), "self" | "entity" | "time" | "tick")
                {
                    errors.push(Diagnostic::new(
                        "system_binding",
                        "callback parameter conflicts with a system binding",
                        parameter.span.clone(),
                    ));
                }
            }
        }
        if !callbacks.contains("frame") {
            errors.push(Diagnostic::new(
                "missing_frame",
                "system requires func frame(dt: Number) -> Unit",
                system.span.clone(),
            ));
        }
    }
    if !errors.is_empty() {
        return Err(errors);
    }
    for (m, module) in &program.modules {
        for c in module.classes.values() {
            program.metadata.symbols.push(symbol(
                m,
                &c.name,
                "type",
                &c.span,
                format!("type {}", c.name),
                &module.exports,
            ));
            for field in &c.fields {
                program.metadata.symbols.push(symbol(
                    m,
                    &format!("{}.{}", c.name, field.name),
                    "field",
                    &field.span,
                    format!("{}: {}", field.name, type_text(&field.ty)),
                    &module.exports,
                ));
            }
        }
        for declaration in module.enums.values() {
            program.metadata.symbols.push(symbol(
                m,
                &declaration.name,
                "enum",
                &declaration.span,
                format!("enum {}", declaration.name),
                &module.exports,
            ));
            for case in &declaration.cases {
                program.metadata.symbols.push(symbol(
                    m,
                    &format!("{}.{}", declaration.name, case.name),
                    "case",
                    &case.span,
                    format!(
                        "{}({})",
                        case.name,
                        case.payload
                            .iter()
                            .map(type_text)
                            .collect::<Vec<_>>()
                            .join(", ")
                    ),
                    &module.exports,
                ));
            }
        }
        for f in module.functions.values() {
            program.metadata.symbols.push(symbol(
                m,
                &f.name,
                "function",
                &f.span,
                function_text(f),
                &module.exports,
            ));
        }
        for t in module.traits.values() {
            program.metadata.symbols.push(symbol(
                m,
                &t.name,
                "trait",
                &t.span,
                format!("trait {}", t.name),
                &module.exports,
            ));
        }
    }
    for (m, s) in &program.systems {
        program.metadata.symbols.push(symbol(
            m,
            &s.name,
            "system",
            &s.span,
            format!(
                "system {} of ({})",
                s.name,
                s.bindings
                    .iter()
                    .map(|b| format!("{}: {}", b.name, type_text(&b.ty)))
                    .collect::<Vec<_>>()
                    .join(", ")
            ),
            &program.modules[m].exports,
        ));
    }
    for (m, source) in &program.sources {
        if let Ok(mut tokens) = tokenize(source, m) {
            program.metadata.tokens.append(&mut tokens);
        }
    }
    for (class, methods) in &program.methods {
        for method in methods.values() {
            program.metadata.methods.push(MethodSymbol {
                class: class.clone(),
                name: method.name.clone(),
                parameter_count: method.parameters.len(),
                span: method.span.clone(),
            });
        }
    }
    program.metadata.modules = program.order.clone();
    crate::typecheck::check(&mut program, registry)?;
    Ok(program)
}