toasty-core 0.3.0

use crate::{
    Schema,
    schema::{
        app::{Field, Model, ModelId, ModelRoot},
        db::{self, Column, ColumnId, Table, TableId},
    },
    stmt::{
        Delete, Expr, ExprArg, ExprColumn, ExprFunc, ExprReference, ExprSet, Insert, InsertTarget,
        Query, Returning, Select, Source, SourceTable, Statement, TableDerived, TableFactor,
        TableRef, Type, TypeUnion, Update, UpdateTarget,
    },
};

/// Provides schema-aware context for expression type inference and reference
/// resolution.
///
/// An `ExprContext` binds a schema reference, an optional parent scope (for
/// nested queries), and a target indicating what the expressions reference
/// (a model, table, or source). It is used by the query engine to infer
/// expression types and resolve column/field references.
///
/// # Examples
///
/// ```ignore
/// use toasty_core::stmt::{ExprContext, ExprTarget};
///
/// let cx = ExprContext::new(&schema);
/// let ty = cx.infer_expr_ty(&expr, &[]);
/// ```
#[derive(Debug)]
pub struct ExprContext<'a, T = Schema> {
    schema: &'a T,
    parent: Option<&'a ExprContext<'a, T>>,
    target: ExprTarget<'a>,
}

/// Result of resolving an `ExprReference` to its concrete schema location.
///
/// When an expression references a field or column (e.g., `user.name` in a
/// WHERE clause), the `ExprContext::resolve_expr_reference()` method returns
/// this enum to indicate whether the reference points to an application field,
/// physical table column, or CTE column.
///
/// This distinction is important for different processing stages: application
/// fields are used during high-level query building, physical columns during
/// SQL generation, and CTE columns require special handling with generated
/// identifiers based on position.
#[derive(Debug)]
pub enum ResolvedRef<'a> {
    /// A resolved reference to a physical database column.
    ///
    /// Contains a reference to the actual Column struct with column metadata including
    /// name, type, and constraints. Used when resolving ExprReference::Column expressions
    /// that point to concrete table columns in the database schema.
    ///
    /// Example: Resolving `user.name` in a query returns Column with name="name",
    /// ty=Type::String from the users table schema.
    Column(&'a Column),

    /// A resolved reference to an application-level field.
    ///
    /// Contains a reference to the Field struct from the application schema,
    /// which includes field metadata like name, type, and model relationships.
    /// Used when resolving ExprReference::Field expressions that point to
    /// model fields before they are lowered to database columns.
    ///
    /// Example: Resolving `User::name` in a query returns Field with name="name"
    /// from the User model's field definitions.
    Field(&'a Field),

    /// A resolved reference to a model
    Model(&'a ModelRoot),

    /// A resolved reference to a Common Table Expression (CTE) column.
    ///
    /// Contains the nesting level and column index for CTE references when resolving
    /// ExprReference::Column expressions that point to CTE outputs rather than physical
    /// table columns. The nesting indicates how many query levels to traverse upward,
    /// and index identifies which column within the CTE's output.
    ///
    /// Example: In a WITH clause, resolving a reference to the second column of a CTE
    /// defined 1 level up returns Cte { nesting: 1, index: 1 }.
    Cte {
        /// How many query scopes up from the current scope.
        nesting: usize,
        /// Column index within the CTE's output.
        index: usize,
    },

    /// A resolved reference to a derived table (subquery in FROM clause) column.
    ///
    /// Contains the nesting level, column index, and a reference to the derived
    /// table itself. This allows consumers to inspect the derived table's
    /// content (e.g., checking VALUES rows for constant values).
    Derived(DerivedRef<'a>),
}

/// A resolved reference into a derived table column.
#[derive(Debug)]
pub struct DerivedRef<'a> {
    /// How many query scopes up from the current scope.
    pub nesting: usize,

    /// The column index within the derived table's output.
    pub index: usize,

    /// Reference to the derived table definition.
    pub derived: &'a TableDerived,
}

impl DerivedRef<'_> {
    /// Returns `true` if the derived table is backed by a VALUES body and every
    /// row has `Null` at this column position.
    ///
    /// Returns `false` conservatively when the body is not VALUES, the VALUES
    /// is empty, or any row doesn't have a recognizable null at the column.
    pub fn is_column_always_null(&self) -> bool {
        let ExprSet::Values(values) = &self.derived.subquery.body else {
            return false;
        };

        if values.is_empty() {
            return false;
        }

        values.rows.iter().all(|row| self.row_column_is_null(row))
    }

    fn row_column_is_null(&self, row: &Expr) -> bool {
        match row {
            Expr::Value(super::Value::Record(record)) => {
                self.index < record.len() && record[self.index].is_null()
            }
            Expr::Record(record) => {
                self.index < record.len()
                    && matches!(&record.fields[self.index], Expr::Value(super::Value::Null))
            }
            Expr::Value(super::Value::Null) => true,
            _ => false,
        }
    }
}

/// What an expression in the current scope references.
///
/// Determines how column and field references are resolved within an
/// [`ExprContext`].
#[derive(Debug, Clone, Copy)]
pub enum ExprTarget<'a> {
    /// Expression does *not* reference any model or table.
    Free,

    /// Expression references a single model
    Model(&'a ModelRoot),

    /// Expression references a single table
    ///
    /// Used primarily by database drivers
    Table(&'a Table),

    /// Expression references a source table (a FROM clause with table references).
    Source(&'a SourceTable),
}

/// Schema resolution trait used by [`ExprContext`] to look up models,
/// tables, and the model-to-table mapping.
///
/// Implemented for [`Schema`], [`db::Schema`](crate::schema::db::Schema),
/// and `()` (which resolves nothing).
pub trait Resolve {
    /// Returns the database table that stores the given model, if any.
    fn table_for_model(&self, model: &ModelRoot) -> Option<&Table>;

    /// Returns a reference to the application Model with the specified ID.
    ///
    /// Used during high-level query building to access model metadata such as
    /// field definitions, relationships, and validation rules. Returns None if
    /// the model ID is not found in the application schema.
    fn model(&self, id: ModelId) -> Option<&Model>;

    /// Returns a reference to the database Table with the specified ID.
    ///
    /// Used during SQL generation and query execution to access table metadata
    /// including column definitions, constraints, and indexes. Returns None if
    /// the table ID is not found in the database schema.
    fn table(&self, id: TableId) -> Option<&Table>;
}

/// Conversion trait for producing an [`ExprTarget`] from a statement or
/// schema element.
pub trait IntoExprTarget<'a, T = Schema> {
    /// Converts `self` into an [`ExprTarget`] using the provided schema.
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a>;
}

#[derive(Debug)]
struct ArgTyStack<'a> {
    tys: &'a [Type],
    parent: Option<&'a ArgTyStack<'a>>,
}

impl<'a, T> ExprContext<'a, T> {
    /// Returns a reference to the schema.
    pub fn schema(&self) -> &'a T {
        self.schema
    }

    /// Returns the current expression target.
    pub fn target(&self) -> ExprTarget<'a> {
        self.target
    }

    /// Return the target at a specific nesting
    pub fn target_at(&self, nesting: usize) -> &ExprTarget<'a> {
        let mut curr = self;

        // Walk up the stack to the correct nesting level
        for _ in 0..nesting {
            let Some(parent) = curr.parent else {
                todo!("bug: invalid nesting level");
            };

            curr = parent;
        }

        &curr.target
    }
}

impl<'a> ExprContext<'a, ()> {
    /// Creates a free context with no schema and no target.
    pub fn new_free() -> ExprContext<'a, ()> {
        ExprContext {
            schema: &(),
            parent: None,
            target: ExprTarget::Free,
        }
    }
}

impl<'a, T: Resolve> ExprContext<'a, T> {
    /// Creates a context bound to the given schema with a free target.
    pub fn new(schema: &'a T) -> ExprContext<'a, T> {
        ExprContext::new_with_target(schema, ExprTarget::Free)
    }

    /// Creates a context bound to the given schema and target.
    pub fn new_with_target(
        schema: &'a T,
        target: impl IntoExprTarget<'a, T>,
    ) -> ExprContext<'a, T> {
        let target = target.into_expr_target(schema);
        ExprContext {
            schema,
            parent: None,
            target,
        }
    }

    /// Creates a child context with a new target, linked to this context
    /// as parent for nested scope resolution.
    pub fn scope<'child>(
        &'child self,
        target: impl IntoExprTarget<'child, T>,
        // target: impl Into<ExprTarget<'child>>,
    ) -> ExprContext<'child, T> {
        let target = target.into_expr_target(self.schema);
        ExprContext {
            schema: self.schema,
            parent: Some(self),
            target,
        }
    }

    /// Resolves an ExprReference::Column reference to the actual database Column it
    /// represents.
    ///
    /// Given an ExprReference::Column (which contains table/column indices and nesting
    /// info), returns the Column struct containing the column's name, type,
    /// constraints, and other metadata.
    ///
    /// Handles:
    /// - Nested query scopes (walking up parent contexts based on nesting
    ///   level)
    /// - Different statement targets (INSERT, UPDATE, SELECT with joins, etc.)
    /// - Table references in multi-table operations (using the table index)
    ///
    /// Used by SQL serialization to get column names, query planning to
    /// match index columns, and key extraction to identify column IDs.
    pub fn resolve_expr_reference(&self, expr_reference: &ExprReference) -> ResolvedRef<'a> {
        let nesting = match expr_reference {
            ExprReference::Column(expr_column) => expr_column.nesting,
            ExprReference::Field { nesting, .. } => *nesting,
            ExprReference::Model { nesting } => *nesting,
        };

        let target = self.target_at(nesting);

        match target {
            ExprTarget::Free => todo!("cannot resolve column in free context"),
            ExprTarget::Model(model) => match expr_reference {
                ExprReference::Model { .. } => ResolvedRef::Model(model),
                ExprReference::Field { index, .. } => ResolvedRef::Field(&model.fields[*index]),
                ExprReference::Column(expr_column) => {
                    assert_eq!(expr_column.table, 0, "TODO: is this true?");

                    let Some(table) = self.schema.table_for_model(model) else {
                        panic!(
                            "Failed to find database table for model '{:?}' - model may not be mapped to a table",
                            model.name
                        )
                    };
                    ResolvedRef::Column(&table.columns[expr_column.column])
                }
            },
            ExprTarget::Table(table) => match expr_reference {
                ExprReference::Model { .. } => {
                    panic!("Cannot resolve ExprReference::Model in Table target context")
                }
                ExprReference::Field { .. } => panic!(
                    "Cannot resolve ExprReference::Field in Table target context - use ExprReference::Column instead"
                ),
                ExprReference::Column(expr_column) => {
                    ResolvedRef::Column(&table.columns[expr_column.column])
                }
            },
            ExprTarget::Source(source_table) => {
                match expr_reference {
                    ExprReference::Column(expr_column) => {
                        // Get the table reference at the specified index
                        let table_ref = &source_table.tables[expr_column.table];
                        match table_ref {
                            TableRef::Table(table_id) => {
                                let Some(table) = self.schema.table(*table_id) else {
                                    panic!(
                                        "Failed to resolve table with ID {:?} - table not found in schema.",
                                        table_id,
                                    );
                                };
                                ResolvedRef::Column(&table.columns[expr_column.column])
                            }
                            TableRef::Derived(derived) => ResolvedRef::Derived(DerivedRef {
                                nesting: expr_column.nesting,
                                index: expr_column.column,
                                derived,
                            }),
                            TableRef::Cte {
                                nesting: cte_nesting,
                                index,
                            } => {
                                // TODO: return more info
                                ResolvedRef::Cte {
                                    nesting: expr_column.nesting + cte_nesting,
                                    index: *index,
                                }
                            }
                            TableRef::Arg(_) => todo!(),
                        }
                    }
                    ExprReference::Model { .. } => {
                        panic!("Cannot resolve ExprReference::Model in Source::Table context")
                    }
                    ExprReference::Field { .. } => panic!(
                        "Cannot resolve ExprReference::Field in Source::Table context - use ExprReference::Column instead"
                    ),
                }
            }
        }
    }

    /// Infers the return type of a statement given argument types.
    pub fn infer_stmt_ty(&self, stmt: &Statement, args: &[Type]) -> Type {
        let cx = self.scope(stmt);

        match stmt {
            Statement::Delete(stmt) => stmt
                .returning
                .as_ref()
                .map(|returning| cx.infer_returning_ty(returning, args, false))
                .unwrap_or(Type::Unit),
            Statement::Insert(stmt) => stmt
                .returning
                .as_ref()
                .map(|returning| cx.infer_returning_ty(returning, args, stmt.source.single))
                .unwrap_or(Type::Unit),
            Statement::Query(stmt) => match &stmt.body {
                ExprSet::Select(body) => cx.infer_returning_ty(&body.returning, args, stmt.single),
                ExprSet::SetOp(_body) => todo!(),
                ExprSet::Update(_body) => todo!(),
                ExprSet::Values(_body) => todo!(),
                ExprSet::Insert(body) => body
                    .returning
                    .as_ref()
                    .map(|returning| cx.infer_returning_ty(returning, args, stmt.single))
                    .unwrap_or(Type::Unit),
            },
            Statement::Update(stmt) => stmt
                .returning
                .as_ref()
                .map(|returning| cx.infer_returning_ty(returning, args, false))
                .unwrap_or(Type::Unit),
        }
    }

    fn infer_returning_ty(&self, returning: &Returning, args: &[Type], single: bool) -> Type {
        let arg_ty_stack = ArgTyStack::new(args);

        match returning {
            Returning::Model { .. } => {
                let ty = Type::Model(
                    self.target
                        .model_id()
                        .expect("returning `Model` when not in model context"),
                );

                if single { ty } else { Type::list(ty) }
            }
            Returning::Changed => todo!(),
            Returning::Expr(expr) => {
                let ty = self.infer_expr_ty2(&arg_ty_stack, expr, false);

                if single { ty } else { Type::list(ty) }
            }
            Returning::Value(expr) => self.infer_expr_ty2(&arg_ty_stack, expr, true),
        }
    }

    /// Infers the type of an expression given argument types.
    pub fn infer_expr_ty(&self, expr: &Expr, args: &[Type]) -> Type {
        let arg_ty_stack = ArgTyStack::new(args);
        self.infer_expr_ty2(&arg_ty_stack, expr, false)
    }

    fn infer_expr_ty2(&self, args: &ArgTyStack<'_>, expr: &Expr, returning_expr: bool) -> Type {
        match expr {
            Expr::Arg(e) => args.resolve_arg_ty(e).clone(),
            Expr::And(_) => Type::Bool,
            Expr::BinaryOp(_) => Type::Bool,
            Expr::Cast(e) => e.ty.clone(),
            Expr::Reference(expr_ref) => {
                assert!(
                    !returning_expr,
                    "should have been handled in Expr::Project. Invalid expr?"
                );
                self.infer_expr_reference_ty(expr_ref)
            }
            Expr::IsNull(_) => Type::Bool,
            Expr::IsVariant(_) => Type::Bool,
            Expr::List(e) => {
                debug_assert!(!e.items.is_empty());
                Type::list(self.infer_expr_ty2(args, &e.items[0], returning_expr))
            }
            Expr::Map(e) => {
                // Compute the map base type
                let base = self.infer_expr_ty2(args, &e.base, returning_expr);

                // The base type should be a list (as it is being mapped)
                let Type::List(item) = base else {
                    todo!("error handling; base={base:#?}")
                };

                let scope_tys = &[*item];

                // Create a new type scope
                let args = args.scope(scope_tys);

                // Infer the type of each map call
                let ty = self.infer_expr_ty2(&args, &e.map, returning_expr);

                // The mapped type is a list
                Type::list(ty)
            }
            Expr::Or(_) => Type::Bool,
            Expr::Project(e) => {
                if returning_expr {
                    match &*e.base {
                        Expr::Arg(expr_arg) => {
                            // When `returning_expr` is `true`, the expression is being
                            // evaluated from a RETURNING EXPR clause. In this case, the
                            // returning expression is *not* a projection. Referencing a
                            // column implies a *list* of
                            assert!(e.projection.as_slice().len() == 1);
                            return args.resolve_arg_ty(expr_arg).clone();
                        }
                        Expr::Reference(expr_reference) => {
                            // When `returning_expr` is `true`, the expression is being
                            // evaluated from a RETURNING EXPR clause. In this case, the
                            // returning expression is *not* a projection. Referencing a
                            // column implies a *list* of
                            assert!(e.projection.as_slice().len() == 1);
                            return self.infer_expr_reference_ty(expr_reference);
                        }
                        _ => {}
                    }
                }

                let mut base = self.infer_expr_ty2(args, &e.base, returning_expr);

                for step in e.projection.iter() {
                    base = match base {
                        Type::Record(mut fields) => {
                            std::mem::replace(&mut fields[*step], Type::Null)
                        }
                        Type::List(items) => *items,
                        expr => todo!(
                            "returning_expr={returning_expr:#?}; expr={expr:#?}; project={e:#?}"
                        ),
                    }
                }

                base
            }
            Expr::Record(e) => Type::Record(
                e.fields
                    .iter()
                    .map(|field| self.infer_expr_ty2(args, field, returning_expr))
                    .collect(),
            ),
            Expr::Value(value) => value.infer_ty(),
            Expr::Let(expr_let) => {
                let scope_tys: Vec<_> = expr_let
                    .bindings
                    .iter()
                    .map(|b| self.infer_expr_ty2(args, b, returning_expr))
                    .collect();
                let args = args.scope(&scope_tys);
                self.infer_expr_ty2(&args, &expr_let.body, returning_expr)
            }
            Expr::Match(expr_match) => {
                // Collect the distinct non-null types from all arms and the else
                // branch. If all agree on one type, return it directly. If they
                // differ, return a Union so callers know exactly which shapes are
                // possible at runtime.
                let mut union = TypeUnion::new();
                for arm in &expr_match.arms {
                    let ty = self.infer_expr_ty2(args, &arm.expr, returning_expr);
                    union.insert(ty);
                }
                let else_ty = self.infer_expr_ty2(args, &expr_match.else_expr, returning_expr);
                union.insert(else_ty);
                union.simplify()
            }
            // Error is a bottom type — it can never be evaluated, so it
            // could be any type. Return Unknown so it unifies with whatever
            // the other branches produce.
            Expr::Error(_) => Type::Unknown,
            Expr::Exists(_) => Type::Bool,
            Expr::Func(ExprFunc::Count(_)) => Type::U64,
            Expr::Func(ExprFunc::LastInsertId(_)) => Type::I64,
            _ => todo!("{expr:#?}"),
        }
    }

    /// Infers the type of an expression reference (field or column).
    pub fn infer_expr_reference_ty(&self, expr_reference: &ExprReference) -> Type {
        match self.resolve_expr_reference(expr_reference) {
            ResolvedRef::Model(model) => Type::Model(model.id),
            ResolvedRef::Column(column) => column.ty.clone(),
            ResolvedRef::Field(field) => field.expr_ty().clone(),
            ResolvedRef::Cte { .. } => todo!("type inference for CTE columns not implemented"),
            ResolvedRef::Derived(_) => {
                todo!("type inference for derived table columns not implemented")
            }
        }
    }
}

impl<'a> ExprContext<'a, Schema> {
    /// Returns the context target as a `ModelRoot` reference, or `None` if the target is not a
    /// model.
    pub fn target_as_model(&self) -> Option<&'a ModelRoot> {
        self.target.as_model()
    }

    /// Creates an `ExprReference::Column` for the given column ID.
    ///
    /// # Panics
    ///
    /// Panics if the context has no table target (`ExprTarget::Free`), if the column does not
    /// belong to the table associated with the current target, or if the target's model has no
    /// mapped database table.
    pub fn expr_ref_column(&self, column_id: impl Into<ColumnId>) -> ExprReference {
        let column_id = column_id.into();

        match self.target {
            ExprTarget::Free => {
                panic!("Cannot create ExprColumn in free context - no table target available")
            }
            ExprTarget::Model(model) => {
                let Some(table) = self.schema.table_for_model(model) else {
                    panic!(
                        "Failed to find database table for model '{:?}' - model may not be mapped to a table",
                        model.name
                    )
                };

                assert_eq!(table.id, column_id.table);
            }
            ExprTarget::Table(table) => assert_eq!(table.id, column_id.table),
            ExprTarget::Source(source_table) => {
                let [TableRef::Table(table_id)] = source_table.tables[..] else {
                    panic!(
                        "Expected exactly one table reference, found {} tables",
                        source_table.tables.len()
                    );
                };
                assert_eq!(table_id, column_id.table);
            }
        }

        ExprReference::Column(ExprColumn {
            nesting: 0,
            table: 0,
            column: column_id.index,
        })
    }
}

impl<'a, T> Clone for ExprContext<'a, T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<'a, T> Copy for ExprContext<'a, T> {}

impl<'a> ResolvedRef<'a> {
    /// Returns the inner `Column` reference.
    ///
    /// # Panics
    ///
    /// Panics if this is not `ResolvedRef::Column`.
    #[track_caller]
    pub fn as_column_unwrap(self) -> &'a Column {
        match self {
            ResolvedRef::Column(column) => column,
            _ => panic!("Expected ResolvedRef::Column, found {:?}", self),
        }
    }

    /// Returns the inner `Field` reference.
    ///
    /// # Panics
    ///
    /// Panics if this is not `ResolvedRef::Field`.
    #[track_caller]
    pub fn as_field_unwrap(self) -> &'a Field {
        match self {
            ResolvedRef::Field(field) => field,
            _ => panic!("Expected ResolvedRef::Field, found {:?}", self),
        }
    }

    /// Returns the inner `ModelRoot` reference.
    ///
    /// # Panics
    ///
    /// Panics if this is not `ResolvedRef::Model`.
    #[track_caller]
    pub fn as_model_unwrap(self) -> &'a ModelRoot {
        match self {
            ResolvedRef::Model(model) => model,
            _ => panic!("Expected ResolvedRef::Model, found {:?}", self),
        }
    }
}

impl Resolve for Schema {
    fn model(&self, id: ModelId) -> Option<&Model> {
        Some(self.app.model(id))
    }

    fn table(&self, id: TableId) -> Option<&Table> {
        Some(self.db.table(id))
    }

    fn table_for_model(&self, model: &ModelRoot) -> Option<&Table> {
        Some(self.table_for(model.id))
    }
}

impl Resolve for db::Schema {
    fn model(&self, _id: ModelId) -> Option<&Model> {
        None
    }

    fn table(&self, id: TableId) -> Option<&Table> {
        Some(db::Schema::table(self, id))
    }

    fn table_for_model(&self, _model: &ModelRoot) -> Option<&Table> {
        None
    }
}

impl Resolve for () {
    fn model(&self, _id: ModelId) -> Option<&Model> {
        None
    }

    fn table(&self, _id: TableId) -> Option<&Table> {
        None
    }

    fn table_for_model(&self, _model: &ModelRoot) -> Option<&Table> {
        None
    }
}

impl<'a> ExprTarget<'a> {
    /// Returns the model if this target is [`ExprTarget::Model`], or `None`.
    pub fn as_model(self) -> Option<&'a ModelRoot> {
        match self {
            ExprTarget::Model(model) => Some(model),
            _ => None,
        }
    }

    /// Returns the model, panicking if not [`ExprTarget::Model`].
    ///
    /// # Panics
    ///
    /// Panics if the target is not `Model`.
    #[track_caller]
    pub fn as_model_unwrap(self) -> &'a ModelRoot {
        match self.as_model() {
            Some(model) => model,
            _ => panic!("expected ExprTarget::Model; was {self:#?}"),
        }
    }

    /// Returns the model ID if this target is [`ExprTarget::Model`], or `None`.
    pub fn model_id(self) -> Option<ModelId> {
        Some(match self {
            ExprTarget::Model(model) => model.id,
            _ => return None,
        })
    }

    /// Returns the table if this target is [`ExprTarget::Table`], or `None`.
    pub fn as_table(self) -> Option<&'a Table> {
        match self {
            ExprTarget::Table(table) => Some(table),
            _ => None,
        }
    }

    /// Returns the table, panicking if not [`ExprTarget::Table`].
    ///
    /// # Panics
    ///
    /// Panics if the target is not `Table`.
    #[track_caller]
    pub fn as_table_unwrap(self) -> &'a Table {
        self.as_table()
            .unwrap_or_else(|| panic!("expected ExprTarget::Table; was {self:#?}"))
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for ExprTarget<'a> {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        match self {
            ExprTarget::Source(source_table) => {
                if source_table.from.len() == 1 && source_table.from[0].joins.is_empty() {
                    match &source_table.from[0].relation {
                        TableFactor::Table(source_table_id) => {
                            debug_assert_eq!(0, source_table_id.0);
                            debug_assert_eq!(1, source_table.tables.len());

                            match &source_table.tables[0] {
                                TableRef::Table(table_id) => {
                                    let table = schema.table(*table_id).unwrap();
                                    ExprTarget::Table(table)
                                }
                                _ => self,
                            }
                        }
                    }
                } else {
                    self
                }
            }
            _ => self,
        }
    }
}

impl<'a, T> IntoExprTarget<'a, T> for &'a ModelRoot {
    fn into_expr_target(self, _schema: &'a T) -> ExprTarget<'a> {
        ExprTarget::Model(self)
    }
}

impl<'a, T> IntoExprTarget<'a, T> for &'a Table {
    fn into_expr_target(self, _schema: &'a T) -> ExprTarget<'a> {
        ExprTarget::Table(self)
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a Query {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        self.body.into_expr_target(schema)
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a ExprSet {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        match self {
            ExprSet::Select(select) => select.into_expr_target(schema),
            ExprSet::SetOp(_) => todo!(),
            ExprSet::Update(update) => update.into_expr_target(schema),
            ExprSet::Values(_) => ExprTarget::Free,
            ExprSet::Insert(insert) => insert.into_expr_target(schema),
        }
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a Select {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        self.source.into_expr_target(schema)
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a Insert {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        self.target.into_expr_target(schema)
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a Update {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        self.target.into_expr_target(schema)
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a Delete {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        self.from.into_expr_target(schema)
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a InsertTarget {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        match self {
            InsertTarget::Scope(query) => query.into_expr_target(schema),
            InsertTarget::Model(model) => {
                let Some(model) = schema.model(*model) else {
                    todo!()
                };
                ExprTarget::Model(model.as_root_unwrap())
            }
            InsertTarget::Table(insert_table) => {
                let table = schema.table(insert_table.table).unwrap();
                ExprTarget::Table(table)
            }
        }
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a UpdateTarget {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        match self {
            UpdateTarget::Query(query) => query.into_expr_target(schema),
            UpdateTarget::Model(model) => {
                let Some(model) = schema.model(*model) else {
                    todo!()
                };
                ExprTarget::Model(model.as_root_unwrap())
            }
            UpdateTarget::Table(table_id) => {
                let Some(table) = schema.table(*table_id) else {
                    todo!()
                };
                ExprTarget::Table(table)
            }
        }
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a Source {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        match self {
            Source::Model(source_model) => {
                let Some(model) = schema.model(source_model.id) else {
                    todo!()
                };
                ExprTarget::Model(model.as_root_unwrap())
            }
            Source::Table(source_table) => {
                ExprTarget::Source(source_table).into_expr_target(schema)
            }
        }
    }
}

impl<'a, T: Resolve> IntoExprTarget<'a, T> for &'a Statement {
    fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a> {
        match self {
            Statement::Delete(stmt) => stmt.into_expr_target(schema),
            Statement::Insert(stmt) => stmt.into_expr_target(schema),
            Statement::Query(stmt) => stmt.into_expr_target(schema),
            Statement::Update(stmt) => stmt.into_expr_target(schema),
        }
    }
}

impl<'a> ArgTyStack<'a> {
    fn new(tys: &'a [Type]) -> ArgTyStack<'a> {
        ArgTyStack { tys, parent: None }
    }

    fn resolve_arg_ty(&self, expr_arg: &ExprArg) -> &'a Type {
        let mut nesting = expr_arg.nesting;
        let mut args = self;

        while nesting > 0 {
            args = args.parent.unwrap();
            nesting -= 1;
        }

        &args.tys[expr_arg.position]
    }

    fn scope<'child>(&'child self, tys: &'child [Type]) -> ArgTyStack<'child> {
        ArgTyStack {
            tys,
            parent: Some(self),
        }
    }
}