eventql_parser/

analysis.rs

use std::{
    borrow::Cow,
    collections::{BTreeMap, HashMap, HashSet, btree_map::Entry},
    mem,
};

use serde::Serialize;
use unicase::Ascii;

use crate::{
    Attrs, Expr, Query, Raw, Source, SourceKind, Type, Value, error::AnalysisError, token::Operator,
};

/// Represents the state of a query that has been statically analyzed.
///
/// This type is used as a marker to indicate that a query has successfully
/// passed static analysis. It contains metadata about the query's type
/// information and variable scope after type checking.
///
/// All variables in a typed query are guaranteed to be:
/// - Properly declared and in scope
/// - Type-safe with sound type assignments
#[derive(Debug, Clone, Serialize)]
pub struct Typed {
    /// The inferred type of the query's projection (PROJECT INTO clause).
    ///
    /// This represents the shape and types of the data that will be
    /// returned by the query.
    pub project: Type,

    /// The variable scope after static analysis.
    ///
    /// Contains all variables that were in scope during type checking,
    /// including bindings from FROM clauses and their associated types.
    #[serde(skip)]
    pub scope: Scope,
}

/// Result type for static analysis operations.
///
/// This is a convenience type alias for `Result<A, AnalysisError>` used throughout
/// the static analysis module.
pub type AnalysisResult<A> = std::result::Result<A, AnalysisError>;

/// Configuration options for static analysis.
///
/// This structure contains the type information needed to perform static analysis
/// on EventQL queries, including the default scope with built-in functions and
/// the type information for event records.
pub struct AnalysisOptions {
    /// The default scope containing built-in functions and their type signatures.
    pub default_scope: Scope,
    /// Type information for event records being queried.
    pub event_type_info: Type,
    /// Custom types that are not defined in the EventQL reference.
    ///
    /// This set allows users to register custom type names that can be used
    /// in type conversion expressions (e.g., `field AS CustomType`). Custom
    /// type names are case-insensitive.
    ///
    /// # Examples
    ///
    /// ```
    /// use eventql_parser::prelude::AnalysisOptions;
    ///
    /// let options = AnalysisOptions::default()
    ///     .add_custom_type("Foobar");
    /// ```
    pub custom_types: HashSet<Ascii<String>>,
}

impl AnalysisOptions {
    /// Adds a custom type name to the analysis options.
    ///
    /// Custom types allow you to use type conversion syntax with types that are
    /// not part of the standard EventQL type system. The type name is stored
    /// case-insensitively.
    ///
    /// # Arguments
    ///
    /// * `value` - The custom type name to register
    ///
    /// # Returns
    ///
    /// Returns `self` to allow for method chaining.
    ///
    /// # Examples
    ///
    /// ```
    /// use eventql_parser::prelude::AnalysisOptions;
    ///
    /// let options = AnalysisOptions::default()
    ///     .add_custom_type("Timestamp")
    ///     .add_custom_type("UUID");
    /// ```
    pub fn add_custom_type<'a>(mut self, value: impl Into<Cow<'a, str>>) -> Self {
        match value.into() {
            Cow::Borrowed(t) => self.custom_types.insert(Ascii::new(t.to_owned())),
            Cow::Owned(t) => self.custom_types.insert(Ascii::new(t)),
        };

        self
    }
}

impl Default for AnalysisOptions {
    fn default() -> Self {
        Self {
            default_scope: Scope {
                entries: HashMap::from([
                    (
                        "ABS".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "CEIL".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "FLOOR".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "ROUND".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "COS".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "EXP".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "POW".to_owned(),
                        Type::App {
                            args: vec![Type::Number, Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "SQRT".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "RAND".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "PI".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "LOWER".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "UPPER".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "TRIM".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "LTRIM".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "RTRIM".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "LEN".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "INSTR".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "SUBSTRING".to_owned(),
                        Type::App {
                            args: vec![Type::String, Type::Number, Type::Number],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "REPLACE".to_owned(),
                        Type::App {
                            args: vec![Type::String, Type::String, Type::String],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "STARTSWITH".to_owned(),
                        Type::App {
                            args: vec![Type::String, Type::String],
                            result: Box::new(Type::Bool),
                        },
                    ),
                    (
                        "ENDSWITH".to_owned(),
                        Type::App {
                            args: vec![Type::String, Type::String],
                            result: Box::new(Type::Bool),
                        },
                    ),
                    (
                        "NOW".to_owned(),
                        Type::App {
                            args: vec![],
                            result: Box::new(Type::String),
                        },
                    ),
                    (
                        "YEAR".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "MONTH".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "DAY".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "HOUR".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "MINUTE".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "SECOND".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "WEEKDAY".to_owned(),
                        Type::App {
                            args: vec![Type::String],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "IF".to_owned(),
                        Type::App {
                            args: vec![Type::Bool, Type::Unspecified, Type::Unspecified],
                            result: Box::new(Type::Unspecified),
                        },
                    ),
                    (
                        "COUNT".to_owned(),
                        Type::App {
                            args: vec![],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "SUM".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "AVG".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "MIN".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "MAX".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "MEDIAN".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "STDDEV".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "VARIANCE".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                    (
                        "UNIQUE".to_owned(),
                        Type::App {
                            args: vec![Type::Number],
                            result: Box::new(Type::Number),
                        },
                    ),
                ]),
            },
            event_type_info: Type::Record(BTreeMap::from([
                ("specversion".to_owned(), Type::String),
                ("id".to_owned(), Type::String),
                ("time".to_owned(), Type::String),
                ("source".to_owned(), Type::String),
                ("subject".to_owned(), Type::Subject),
                ("type".to_owned(), Type::String),
                ("datacontenttype".to_owned(), Type::String),
                ("data".to_owned(), Type::Unspecified),
                ("predecessorhash".to_owned(), Type::String),
                ("hash".to_owned(), Type::String),
                ("traceparent".to_owned(), Type::String),
                ("tracestate".to_owned(), Type::String),
                ("signature".to_owned(), Type::String),
            ])),
            custom_types: HashSet::default(),
        }
    }
}

/// Performs static analysis on an EventQL query.
///
/// This function takes a raw (untyped) query and performs type checking and
/// variable scoping analysis. It validates that:
/// - All variables are properly declared
/// - Types match expected types in expressions and operations
/// - Field accesses are valid for their record types
/// - Function calls have the correct argument types
///
/// # Arguments
///
/// * `options` - Configuration containing type information and default scope
/// * `query` - The raw query to analyze
///
/// # Returns
///
/// Returns a typed query on success, or an `AnalysisError` if type checking fails.
pub fn static_analysis(
    options: &AnalysisOptions,
    query: Query<Raw>,
) -> AnalysisResult<Query<Typed>> {
    let mut analysis = Analysis::new(options);

    analysis.analyze_query(query)
}

/// Represents a variable scope during static analysis.
///
/// A scope tracks the variables and their types that are currently in scope
/// during type checking. This is used to resolve variable references and
/// ensure type correctness.
#[derive(Default, Serialize, Clone, Debug)]
pub struct Scope {
    /// Map of variable names to their types.
    pub entries: HashMap<String, Type>,
}

impl Scope {
    /// Checks if the scope contains no entries.
    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }
}

struct Analysis<'a> {
    options: &'a AnalysisOptions,
    prev_scopes: Vec<Scope>,
    scope: Scope,
}

impl<'a> Analysis<'a> {
    fn new(options: &'a AnalysisOptions) -> Self {
        Self {
            options,
            prev_scopes: Default::default(),
            scope: Scope::default(),
        }
    }

    fn enter_scope(&mut self) {
        if self.scope.is_empty() {
            return;
        }

        let prev = mem::take(&mut self.scope);
        self.prev_scopes.push(prev);
    }

    fn exit_scope(&mut self) -> Scope {
        if let Some(prev) = self.prev_scopes.pop() {
            mem::replace(&mut self.scope, prev)
        } else {
            mem::take(&mut self.scope)
        }
    }

    fn analyze_query(&mut self, query: Query<Raw>) -> AnalysisResult<Query<Typed>> {
        self.enter_scope();

        let mut sources = Vec::with_capacity(query.sources.len());

        for source in query.sources {
            sources.push(self.analyze_source(source)?);
        }

        if let Some(expr) = &query.predicate {
            self.analyze_expr(expr, Type::Bool)?;
        }

        if let Some(group_by) = &query.group_by {
            if !matches!(&group_by.expr.value, Value::Access(_)) {
                return Err(AnalysisError::ExpectFieldLiteral(
                    group_by.expr.attrs.pos.line,
                    group_by.expr.attrs.pos.col,
                ));
            }

            self.analyze_expr(&group_by.expr, Type::Unspecified)?;

            if let Some(expr) = &group_by.predicate {
                self.analyze_expr(expr, Type::Bool)?;
            }
        }

        if let Some(order_by) = &query.order_by {
            if !matches!(&order_by.expr.value, Value::Access(_)) {
                return Err(AnalysisError::ExpectFieldLiteral(
                    order_by.expr.attrs.pos.line,
                    order_by.expr.attrs.pos.col,
                ));
            }
            self.analyze_expr(&order_by.expr, Type::Unspecified)?;
        }

        if !matches!(&query.projection.value, Value::Record(_) | Value::Id(_)) {
            return Err(AnalysisError::ExpectRecordLiteral(
                query.projection.attrs.pos.line,
                query.projection.attrs.pos.col,
            ));
        }

        let project = self.analyze_expr(&query.projection, Type::Unspecified)?;

        if !matches!(&project, Type::Record(f) if !f.is_empty()) {
            return Err(AnalysisError::ExpectRecord(
                query.projection.attrs.pos.line,
                query.projection.attrs.pos.col,
                project,
            ));
        }

        let scope = self.exit_scope();

        Ok(Query {
            attrs: query.attrs,
            sources,
            predicate: query.predicate,
            group_by: query.group_by,
            order_by: query.order_by,
            limit: query.limit,
            projection: query.projection,
            distinct: query.distinct,
            meta: Typed { project, scope },
        })
    }

    fn analyze_source(&mut self, source: Source<Raw>) -> AnalysisResult<Source<Typed>> {
        let kind = self.analyze_source_kind(source.kind)?;
        let tpe = match &kind {
            SourceKind::Name(_) | SourceKind::Subject(_) => self.options.event_type_info.clone(),
            SourceKind::Subquery(query) => self.projection_type(query),
        };

        if self
            .scope
            .entries
            .insert(source.binding.name.clone(), tpe)
            .is_some()
        {
            return Err(AnalysisError::BindingAlreadyExists(
                source.binding.pos.line,
                source.binding.pos.col,
                source.binding.name,
            ));
        }

        Ok(Source {
            binding: source.binding,
            kind,
        })
    }

    fn analyze_source_kind(&mut self, kind: SourceKind<Raw>) -> AnalysisResult<SourceKind<Typed>> {
        match kind {
            SourceKind::Name(n) => Ok(SourceKind::Name(n)),
            SourceKind::Subject(s) => Ok(SourceKind::Subject(s)),
            SourceKind::Subquery(query) => {
                let query = self.analyze_query(*query)?;
                Ok(SourceKind::Subquery(Box::new(query)))
            }
        }
    }

    fn analyze_expr(&mut self, expr: &Expr, expect: Type) -> AnalysisResult<Type> {
        self.analyze_value(&expr.attrs, &expr.value, expect)
    }

    fn analyze_value(
        &mut self,
        attrs: &Attrs,
        value: &Value,
        mut expect: Type,
    ) -> AnalysisResult<Type> {
        match value {
            Value::Number(_) => expect.check(attrs, Type::Number),
            Value::String(_) => expect.check(attrs, Type::String),
            Value::Bool(_) => expect.check(attrs, Type::Bool),

            Value::Id(id) => {
                if let Some(tpe) = self.options.default_scope.entries.get(id) {
                    expect.check(attrs, tpe.clone())
                } else if let Some(tpe) = self.scope.entries.get_mut(id.as_str()) {
                    let tmp = mem::take(tpe);
                    *tpe = tmp.check(attrs, expect)?;

                    Ok(tpe.clone())
                } else {
                    Err(AnalysisError::VariableUndeclared(
                        attrs.pos.line,
                        attrs.pos.col,
                        id.to_owned(),
                    ))
                }
            }

            Value::Array(exprs) => {
                if matches!(expect, Type::Unspecified) {
                    for expr in exprs {
                        expect = self.analyze_expr(expr, expect)?;
                    }

                    return Ok(Type::Array(Box::new(expect)));
                }

                match expect {
                    Type::Array(mut expect) => {
                        for expr in exprs {
                            *expect = self.analyze_expr(expr, expect.as_ref().clone())?;
                        }

                        Ok(Type::Array(expect))
                    }

                    expect => Err(AnalysisError::TypeMismatch(
                        attrs.pos.line,
                        attrs.pos.col,
                        expect,
                        self.project_type(value),
                    )),
                }
            }

            Value::Record(fields) => {
                if matches!(expect, Type::Unspecified) {
                    let mut record = BTreeMap::new();

                    for field in fields {
                        record.insert(
                            field.name.clone(),
                            self.analyze_value(
                                &field.value.attrs,
                                &field.value.value,
                                Type::Unspecified,
                            )?,
                        );
                    }

                    return Ok(Type::Record(record));
                }

                match expect {
                    Type::Record(mut types) if fields.len() == types.len() => {
                        for field in fields {
                            if let Some(tpe) = types.remove(field.name.as_str()) {
                                types.insert(
                                    field.name.clone(),
                                    self.analyze_expr(&field.value, tpe)?,
                                );
                            } else {
                                return Err(AnalysisError::FieldUndeclared(
                                    attrs.pos.line,
                                    attrs.pos.col,
                                    field.name.clone(),
                                ));
                            }
                        }

                        Ok(Type::Record(types))
                    }

                    expect => Err(AnalysisError::TypeMismatch(
                        attrs.pos.line,
                        attrs.pos.col,
                        expect,
                        self.project_type(value),
                    )),
                }
            }

            this @ Value::Access(_) => Ok(self.analyze_access(attrs, this, expect)?),

            this @ Value::App(app) => {
                if matches!(expect, Type::Unspecified) {
                    return Ok(self.project_type(this));
                }

                match expect {
                    Type::App { args, mut result } if app.args.len() == args.len() => {
                        let mut arg_types = Vec::with_capacity(args.capacity());
                        for (arg, tpe) in app.args.iter().zip(args.into_iter()) {
                            arg_types.push(self.analyze_expr(arg, tpe)?);
                        }

                        if let Some(tpe) = self.options.default_scope.entries.get(app.func.as_str())
                        {
                            let tmp = mem::take(result.as_mut());
                            *result = tmp.check(attrs, tpe.clone())?;

                            Ok(Type::App {
                                args: arg_types,
                                result,
                            })
                        } else {
                            Err(AnalysisError::FuncUndeclared(
                                attrs.pos.line,
                                attrs.pos.col,
                                app.func.clone(),
                            ))
                        }
                    }

                    expect => Err(AnalysisError::TypeMismatch(
                        attrs.pos.line,
                        attrs.pos.col,
                        expect,
                        self.project_type(value),
                    )),
                }
            }

            Value::Binary(binary) => match binary.operator {
                Operator::Add | Operator::Sub | Operator::Mul | Operator::Div => {
                    self.analyze_expr(&binary.lhs, Type::Number)?;
                    self.analyze_expr(&binary.rhs, Type::Number)?;
                    expect.check(attrs, Type::Number)
                }

                Operator::Eq
                | Operator::Neq
                | Operator::Lt
                | Operator::Lte
                | Operator::Gt
                | Operator::Gte => {
                    let lhs_expect = self.analyze_expr(&binary.lhs, Type::Unspecified)?;
                    let rhs_expect = self.analyze_expr(&binary.rhs, lhs_expect.clone())?;

                    // If the left side didn't have enough type information while the other did,
                    // we replay another typecheck pass on the left side if the right side was conclusive
                    if matches!(lhs_expect, Type::Unspecified)
                        && !matches!(rhs_expect, Type::Unspecified)
                    {
                        self.analyze_expr(&binary.lhs, rhs_expect)?;
                    }

                    expect.check(attrs, Type::Bool)
                }

                Operator::Contains => {
                    let lhs_expect =
                        self.analyze_expr(&binary.lhs, Type::Array(Box::new(Type::Unspecified)))?;

                    let lhs_assumption = match lhs_expect {
                        Type::Array(inner) => *inner,
                        other => {
                            return Err(AnalysisError::ExpectArray(
                                attrs.pos.line,
                                attrs.pos.col,
                                other,
                            ));
                        }
                    };

                    let rhs_expect = self.analyze_expr(&binary.rhs, lhs_assumption.clone())?;

                    // If the left side didn't have enough type information while the other did,
                    // we replay another typecheck pass on the left side if the right side was conclusive
                    if matches!(lhs_assumption, Type::Unspecified)
                        && !matches!(rhs_expect, Type::Unspecified)
                    {
                        self.analyze_expr(&binary.lhs, Type::Array(Box::new(rhs_expect)))?;
                    }

                    expect.check(attrs, Type::Bool)
                }

                Operator::And | Operator::Or | Operator::Xor => {
                    self.analyze_expr(&binary.lhs, Type::Bool)?;
                    self.analyze_expr(&binary.rhs, Type::Bool)?;

                    expect.check(attrs, Type::Bool)
                }

                Operator::As => {
                    if let Value::Id(name) = &binary.rhs.value {
                        if let Some(tpe) = name_to_type(self.options, name) {
                            // NOTE - we could check if it's safe to convert the left branch to that type
                            return Ok(tpe);
                        } else {
                            return Err(AnalysisError::UnsupportedCustomType(
                                attrs.pos.line,
                                attrs.pos.col,
                                name.clone(),
                            ));
                        }
                    }

                    unreachable!(
                        "we already made sure during parsing that we can only have an ID symbol at this point"
                    )
                }

                Operator::Not => unreachable!(),
            },

            Value::Unary(unary) => match unary.operator {
                Operator::Add | Operator::Sub => {
                    self.analyze_expr(&unary.expr, Type::Number)?;
                    expect.check(attrs, Type::Number)
                }

                Operator::Not => {
                    self.analyze_expr(&unary.expr, Type::Bool)?;
                    expect.check(attrs, Type::Bool)
                }

                _ => unreachable!(),
            },

            Value::Group(expr) => Ok(self.analyze_expr(expr.as_ref(), expect)?),
        }
    }

    fn analyze_access(
        &mut self,
        attrs: &Attrs,
        access: &Value,
        expect: Type,
    ) -> AnalysisResult<Type> {
        struct State<A, B> {
            depth: u8,
            /// When true means we are into dynamically type object.
            dynamic: bool,
            definition: Def<A, B>,
        }

        impl<A, B> State<A, B> {
            fn new(definition: Def<A, B>) -> Self {
                Self {
                    depth: 0,
                    dynamic: false,
                    definition,
                }
            }
        }

        enum Def<A, B> {
            User(A),
            System(B),
        }

        fn go<'a>(
            scope: &'a mut Scope,
            sys: &'a AnalysisOptions,
            attrs: &'a Attrs,
            value: &'a Value,
        ) -> AnalysisResult<State<&'a mut Type, &'a Type>> {
            match value {
                Value::Id(id) => {
                    if let Some(tpe) = sys.default_scope.entries.get(id.as_str()) {
                        Ok(State::new(Def::System(tpe)))
                    } else if let Some(tpe) = scope.entries.get_mut(id.as_str()) {
                        Ok(State::new(Def::User(tpe)))
                    } else {
                        Err(AnalysisError::VariableUndeclared(
                            attrs.pos.line,
                            attrs.pos.col,
                            id.clone(),
                        ))
                    }
                }
                Value::Access(access) => {
                    let mut state = go(scope, sys, &access.target.attrs, &access.target.value)?;

                    // TODO - we should consider make that field and depth configurable.
                    let is_data_field = state.depth == 0 && access.field == "data";

                    // TODO - we should consider make that behavior configurable.
                    // the `data` property is where the JSON payload is located, which means
                    // we should be lax if a property is not defined yet.
                    if !state.dynamic && is_data_field {
                        state.dynamic = true;
                    }

                    match state.definition {
                        Def::User(tpe) => {
                            if matches!(tpe, Type::Unspecified) && state.dynamic {
                                *tpe = Type::Record(BTreeMap::from([(
                                    access.field.clone(),
                                    Type::Unspecified,
                                )]));
                                return Ok(State {
                                    depth: state.depth + 1,
                                    definition: Def::User(
                                        tpe.as_record_or_panic_mut()
                                            .get_mut(access.field.as_str())
                                            .unwrap(),
                                    ),
                                    ..state
                                });
                            }

                            if let Type::Record(fields) = tpe {
                                match fields.entry(access.field.clone()) {
                                    Entry::Vacant(entry) => {
                                        if state.dynamic || is_data_field {
                                            return Ok(State {
                                                depth: state.depth + 1,
                                                definition: Def::User(
                                                    entry.insert(Type::Unspecified),
                                                ),
                                                ..state
                                            });
                                        }

                                        return Err(AnalysisError::FieldUndeclared(
                                            attrs.pos.line,
                                            attrs.pos.col,
                                            access.field.clone(),
                                        ));
                                    }

                                    Entry::Occupied(entry) => {
                                        return Ok(State {
                                            depth: state.depth + 1,
                                            definition: Def::User(entry.into_mut()),
                                            ..state
                                        });
                                    }
                                }
                            }

                            Err(AnalysisError::ExpectRecord(
                                attrs.pos.line,
                                attrs.pos.col,
                                tpe.clone(),
                            ))
                        }

                        Def::System(tpe) => {
                            if matches!(tpe, Type::Unspecified) && state.dynamic {
                                return Ok(State {
                                    depth: state.depth + 1,
                                    definition: Def::System(&Type::Unspecified),
                                    ..state
                                });
                            }

                            if let Type::Record(fields) = tpe {
                                if let Some(field) = fields.get(access.field.as_str()) {
                                    return Ok(State {
                                        depth: state.depth + 1,
                                        definition: Def::System(field),
                                        ..state
                                    });
                                }

                                return Err(AnalysisError::FieldUndeclared(
                                    attrs.pos.line,
                                    attrs.pos.col,
                                    access.field.clone(),
                                ));
                            }

                            Err(AnalysisError::ExpectRecord(
                                attrs.pos.line,
                                attrs.pos.col,
                                tpe.clone(),
                            ))
                        }
                    }
                }
                Value::Number(_)
                | Value::String(_)
                | Value::Bool(_)
                | Value::Array(_)
                | Value::Record(_)
                | Value::App(_)
                | Value::Binary(_)
                | Value::Unary(_)
                | Value::Group(_) => unreachable!(),
            }
        }

        let state = go(&mut self.scope, self.options, attrs, access)?;

        match state.definition {
            Def::User(tpe) => {
                let tmp = mem::take(tpe);
                *tpe = tmp.check(attrs, expect)?;

                Ok(tpe.clone())
            }

            Def::System(tpe) => tpe.clone().check(attrs, expect),
        }
    }

    fn projection_type(&self, query: &Query<Typed>) -> Type {
        self.project_type(&query.projection.value)
    }

    fn project_type(&self, value: &Value) -> Type {
        match value {
            Value::Number(_) => Type::Number,
            Value::String(_) => Type::String,
            Value::Bool(_) => Type::Bool,
            Value::Id(id) => {
                if let Some(tpe) = self.options.default_scope.entries.get(id) {
                    tpe.clone()
                } else if let Some(tpe) = self.scope.entries.get(id) {
                    tpe.clone()
                } else {
                    Type::Unspecified
                }
            }
            Value::Array(exprs) => {
                let mut project = Type::Unspecified;

                for expr in exprs {
                    let tmp = self.project_type(&expr.value);

                    if !matches!(tmp, Type::Unspecified) {
                        project = tmp;
                        break;
                    }
                }

                Type::Array(Box::new(project))
            }
            Value::Record(fields) => Type::Record(
                fields
                    .iter()
                    .map(|field| (field.name.clone(), self.project_type(&field.value.value)))
                    .collect(),
            ),
            Value::Access(access) => {
                let tpe = self.project_type(&access.target.value);
                if let Type::Record(fields) = tpe {
                    fields
                        .get(access.field.as_str())
                        .cloned()
                        .unwrap_or_default()
                } else {
                    Type::Unspecified
                }
            }
            Value::App(app) => self
                .options
                .default_scope
                .entries
                .get(app.func.as_str())
                .cloned()
                .unwrap_or_default(),
            Value::Binary(binary) => match binary.operator {
                Operator::Add | Operator::Sub | Operator::Mul | Operator::Div => Type::Number,
                Operator::As => {
                    if let Value::Id(n) = &binary.rhs.as_ref().value
                        && let Some(tpe) = name_to_type(self.options, n.as_str())
                    {
                        tpe
                    } else {
                        Type::Unspecified
                    }
                }
                Operator::Eq
                | Operator::Neq
                | Operator::Lt
                | Operator::Lte
                | Operator::Gt
                | Operator::Gte
                | Operator::And
                | Operator::Or
                | Operator::Xor
                | Operator::Not
                | Operator::Contains => Type::Bool,
            },
            Value::Unary(unary) => match unary.operator {
                Operator::Add | Operator::Sub => Type::Number,
                Operator::Mul
                | Operator::Div
                | Operator::Eq
                | Operator::Neq
                | Operator::Lt
                | Operator::Lte
                | Operator::Gt
                | Operator::Gte
                | Operator::And
                | Operator::Or
                | Operator::Xor
                | Operator::Not
                | Operator::Contains
                | Operator::As => unreachable!(),
            },
            Value::Group(expr) => self.project_type(&expr.value),
        }
    }
}

fn name_to_type(opts: &AnalysisOptions, name: &str) -> Option<Type> {
    if name.eq_ignore_ascii_case("string") {
        Some(Type::String)
    } else if name.eq_ignore_ascii_case("int") || name.eq_ignore_ascii_case("float64") {
        Some(Type::Number)
    } else if name.eq_ignore_ascii_case("boolean") {
        Some(Type::Bool)
    } else if name.eq_ignore_ascii_case("date") {
        Some(Type::Date)
    } else if name.eq_ignore_ascii_case("time") {
        Some(Type::Time)
    } else if name.eq_ignore_ascii_case("datetime") {
        Some(Type::DateTime)
    } else if opts.custom_types.contains(&Ascii::new(name.to_owned())) {
        // ^ Sad we have to allocate here for no reason
        Some(Type::Custom(name.to_owned()))
    } else {
        None
    }
}