tsz-checker 0.1.9

//! Namespace type merging and re-export resolution for declaration merging.

use crate::query_boundaries::class_type as query;
use crate::state::CheckerState;
use std::sync::Arc;
use tsz_binder::SymbolId;
use tsz_common::interner::Atom;
use tsz_parser::NodeIndex;
use tsz_solver::TypeId;
use tsz_solver::Visibility;

// =============================================================================
// Namespace Type Checking
// =============================================================================

impl<'a> CheckerState<'a> {
    // =========================================================================
    // Namespace Export Merging
    // =========================================================================

    /// Merge namespace exports into a constructor type for class+namespace merging.
    ///
    /// When a class and namespace are merged (same name), the namespace's exports
    /// become accessible as static properties on the class constructor type.
    ///
    /// ## TypeScript Example:
    /// ```typescript
    /// class Foo {
    ///   static bar = 1;
    /// }
    /// namespace Foo {
    ///   export const baz = 2;
    /// }
    /// // Foo.bar and Foo.baz are both accessible
    /// ```
    pub(crate) fn merge_namespace_exports_into_constructor(
        &mut self,
        sym_id: SymbolId,
        ctor_type: TypeId,
    ) -> TypeId {
        use rustc_hash::FxHashMap;
        use tsz_solver::{CallableShape, PropertyInfo};
        let factory = self.ctx.types.factory();

        // Check recursion depth to prevent stack overflow
        const MAX_MERGE_DEPTH: u32 = 32;
        let depth = self.ctx.symbol_resolution_depth.get();
        if depth >= MAX_MERGE_DEPTH {
            return ctor_type; // Prevent infinite recursion in merge
        }

        let Some(symbol) = self.ctx.binder.get_symbol(sym_id) else {
            return ctor_type;
        };
        let Some(exports) = symbol.exports.as_ref() else {
            return ctor_type;
        };
        let Some(shape) = query::callable_shape_for_type(self.ctx.types, ctor_type) else {
            return ctor_type;
        };

        let mut props: FxHashMap<Atom, PropertyInfo> = shape
            .properties
            .iter()
            .map(|prop| (prop.name, prop.clone()))
            .collect();

        // Merge ALL exports from the namespace into the constructor type.
        // This includes both value exports (consts, functions) and type-only exports (interfaces, type aliases).
        // For merged class+namespace symbols, TypeScript allows accessing both value and type members.
        for (name, member_id) in exports.iter() {
            // Skip if this member is already being resolved (prevents infinite recursion)
            if self.ctx.symbol_resolution_set.contains(member_id) {
                continue; // Skip circular references
            }

            let type_id = self.get_type_of_symbol(*member_id);
            let name_atom = self.ctx.types.intern_string(name);

            // Check for duplicate identifiers (TS2300)
            // When a class static member and namespace export share the same name.
            // Classes also have an implicit static `prototype` property, even when it's
            // not materialized in the constructor shape.
            let is_implicit_class_prototype = name == "prototype";
            if props.contains_key(&name_atom) || is_implicit_class_prototype {
                // Get the namespace export symbol to report error at its location
                if let Some(export_symbol) = self.ctx.binder.get_symbol(*member_id) {
                    let error_node = export_symbol.value_declaration;
                    if error_node != NodeIndex::NONE {
                        use tsz_common::diagnostics::diagnostic_codes;
                        self.error_at_node_msg(
                            error_node,
                            diagnostic_codes::DUPLICATE_IDENTIFIER,
                            &[name],
                        );
                    }
                }
                // Skip adding this duplicate property
                continue;
            }

            props.insert(
                name_atom,
                PropertyInfo {
                    name: name_atom,
                    type_id,
                    write_type: type_id,
                    optional: false,
                    readonly: false,
                    is_method: false,
                    visibility: Visibility::Public,
                    parent_id: None,
                },
            );
        }

        let properties: Vec<PropertyInfo> = props.into_values().collect();
        let call_shape = CallableShape {
            call_signatures: shape.call_signatures.clone(),
            construct_signatures: shape.construct_signatures.clone(),
            properties,
            string_index: shape.string_index.clone(),
            number_index: shape.number_index.clone(),
            symbol: None,
        };

        factory.callable(call_shape)
    }

    /// Merge namespace exports into a function type for function+namespace merging.
    ///
    /// This is similar to `merge_namespace_exports_into_constructor` but for functions.
    /// When a function and namespace are merged (same name), the namespace's exports
    /// become accessible as static properties on the function type.
    ///
    /// ## TypeScript Example:
    /// ```typescript
    /// function Model() {}
    /// namespace Model {
    ///   export interface Options {}
    /// }
    /// let opts: Model.Options;  // Works because Options is merged into Model
    /// ```
    pub(crate) fn merge_namespace_exports_into_function(
        &mut self,
        sym_id: SymbolId,
        function_type: TypeId,
    ) -> (TypeId, Vec<tsz_solver::TypeParamInfo>) {
        use rustc_hash::FxHashMap;
        use tsz_solver::{CallableShape, PropertyInfo};

        let Some(symbol) = self.ctx.binder.get_symbol(sym_id) else {
            return (function_type, Vec::new());
        };
        let Some(exports) = symbol.exports.as_ref() else {
            return (function_type, Vec::new());
        };

        // Get the callable shape from the function type.
        // Handle both TypeData::Callable (overloaded functions) and TypeData::Function
        // (simple single-signature functions) by converting Function to a CallableShape.
        let shape: std::sync::Arc<CallableShape> =
            if let Some(s) = query::callable_shape_for_type(self.ctx.types, function_type) {
                s
            } else if let Some(func_shape_id) =
                tsz_solver::visitor::function_shape_id(self.ctx.types, function_type)
            {
                let func_shape = self.ctx.types.function_shape(func_shape_id);
                std::sync::Arc::new(CallableShape {
                    call_signatures: vec![tsz_solver::CallSignature {
                        type_params: func_shape.type_params.clone(),
                        params: func_shape.params.clone(),
                        this_type: func_shape.this_type,
                        return_type: func_shape.return_type,
                        type_predicate: func_shape.type_predicate.clone(),
                        is_method: func_shape.is_method,
                    }],
                    construct_signatures: Vec::new(),
                    properties: Vec::new(),
                    string_index: None,
                    number_index: None,
                    symbol: None,
                })
            } else {
                return (function_type, Vec::new());
            };

        let mut props: FxHashMap<Atom, PropertyInfo> = shape
            .properties
            .iter()
            .map(|prop| (prop.name, prop.clone()))
            .collect();

        // Merge ALL exports from the namespace into the function type.
        // This allows accessing namespace members via FunctionName.Member.
        for (name, member_id) in exports.iter() {
            // Skip if this member is already being resolved (prevents infinite recursion)
            if self.ctx.symbol_resolution_set.contains(member_id) {
                continue; // Skip circular references
            }

            let type_id = self.get_type_of_symbol(*member_id);
            let name_atom = self.ctx.types.intern_string(name);

            // Check for duplicate identifiers (TS2300)
            // When a function property and namespace export share the same name
            if props.contains_key(&name_atom) {
                // Get the namespace export symbol to report error at its location
                if let Some(export_symbol) = self.ctx.binder.get_symbol(*member_id) {
                    let error_node = export_symbol.value_declaration;
                    if error_node != NodeIndex::NONE {
                        use tsz_common::diagnostics::diagnostic_codes;
                        self.error_at_node_msg(
                            error_node,
                            diagnostic_codes::DUPLICATE_IDENTIFIER,
                            &[name],
                        );
                    }
                }
                // Skip adding this duplicate property
                continue;
            }

            props.insert(
                name_atom,
                PropertyInfo {
                    name: name_atom,
                    type_id,
                    write_type: type_id,
                    optional: false,
                    readonly: false,
                    is_method: false,
                    visibility: Visibility::Public,
                    parent_id: None,
                },
            );
        }

        let properties: Vec<PropertyInfo> = props.into_values().collect();
        let factory = self.ctx.types.factory();
        let merged_type = factory.callable(CallableShape {
            call_signatures: shape.call_signatures.clone(),
            construct_signatures: shape.construct_signatures.clone(),
            properties,
            string_index: shape.string_index.clone(),
            number_index: shape.number_index.clone(),
            symbol: None,
        });

        (merged_type, Vec::new())
    }

    // =========================================================================
    // Re-export Resolution
    // =========================================================================

    /// Resolve a re-exported member from a module by following re-export chains.
    ///
    /// This function handles cases where a namespace member is re-exported from
    /// another module using `export { foo } from './bar'` or `export * from './bar'`.
    ///
    /// ## Re-export Chain Resolution:
    /// 1. Check if the member is directly exported from the module
    /// 2. If not, check for named re-exports: `export { foo } from 'bar'`
    /// 3. If not found, check wildcard re-exports: `export * from 'bar'`
    /// 4. Recursively follow re-export chains to find the original member
    ///
    /// ## TypeScript Examples:
    /// ```typescript
    /// // bar.ts
    /// export const foo = 42;
    ///
    /// // a.ts
    /// export { foo } from './bar';
    ///
    /// // b.ts
    /// export * from './a';
    ///
    /// // main.ts
    /// import * as b from './b';
    /// let x = b.foo;  // Should find foo through re-export chain
    /// ```
    pub(crate) fn resolve_reexported_member(
        &self,
        module_specifier: &str,
        member_name: &str,
        lib_binders: &[Arc<tsz_binder::BinderState>],
    ) -> Option<SymbolId> {
        let lookup_in_exports = |binder: &tsz_binder::BinderState,
                                 module_exports: &tsz_binder::SymbolTable|
         -> Option<SymbolId> {
            if let Some(sym_id) = module_exports.get(member_name) {
                return Some(sym_id);
            }

            let export_equals_sym_id = module_exports.get("export=")?;
            let export_equals_symbol = binder.get_symbol(export_equals_sym_id)?;

            if let Some(exports) = export_equals_symbol.exports.as_ref()
                && let Some(sym_id) = exports.get(member_name)
            {
                return Some(sym_id);
            }

            if let Some(members) = export_equals_symbol.members.as_ref()
                && let Some(sym_id) = members.get(member_name)
            {
                return Some(sym_id);
            }

            for candidate_id in binder
                .get_symbols()
                .find_all_by_name(&export_equals_symbol.escaped_name)
            {
                let Some(candidate_symbol) = binder.get_symbol(candidate_id) else {
                    continue;
                };
                if (candidate_symbol.flags
                    & (tsz_binder::symbol_flags::MODULE
                        | tsz_binder::symbol_flags::NAMESPACE_MODULE
                        | tsz_binder::symbol_flags::VALUE_MODULE))
                    == 0
                {
                    continue;
                }
                if let Some(exports) = candidate_symbol.exports.as_ref()
                    && let Some(sym_id) = exports.get(member_name)
                {
                    return Some(sym_id);
                }
                if let Some(members) = candidate_symbol.members.as_ref()
                    && let Some(sym_id) = members.get(member_name)
                {
                    return Some(sym_id);
                }
            }

            None
        };

        // First, check if it's a direct export from this module
        if let Some(module_exports) = self.ctx.binder.module_exports.get(module_specifier)
            && let Some(sym_id) = lookup_in_exports(self.ctx.binder, module_exports)
        {
            // Found direct export - but we need to resolve if it's itself a re-export
            // Get the symbol and check if it's an alias
            if let Some(symbol) = self.ctx.binder.get_symbol(sym_id)
                && symbol.flags & tsz_binder::symbol_flags::ALIAS != 0
            {
                // Follow the alias
                if let Some(ref import_module) = symbol.import_module {
                    let export_name = symbol.import_name.as_deref().unwrap_or(member_name);
                    return self.resolve_reexported_member(import_module, export_name, lib_binders);
                }
            }
            return Some(sym_id);
        }

        // Check for named re-exports: `export { foo } from 'bar'`
        if let Some(file_reexports) = self.ctx.binder.reexports.get(module_specifier)
            && let Some((source_module, original_name)) = file_reexports.get(member_name)
        {
            let name_to_lookup = original_name.as_deref().unwrap_or(member_name);
            return self.resolve_reexported_member(source_module, name_to_lookup, lib_binders);
        }

        // Check for wildcard re-exports: `export * from 'bar'`
        if let Some(source_modules) = self.ctx.binder.wildcard_reexports.get(module_specifier) {
            for source_module in source_modules {
                if let Some(sym_id) =
                    self.resolve_reexported_member(source_module, member_name, lib_binders)
                {
                    return Some(sym_id);
                }
            }
        }

        // Check lib binders for the module
        for lib_binder in lib_binders {
            // First check lib binder's module_exports
            if let Some(module_exports) = lib_binder.module_exports.get(module_specifier)
                && let Some(sym_id) = lookup_in_exports(lib_binder, module_exports)
            {
                return Some(sym_id);
            }
            // Then check lib binder's re-exports
            if let Some(file_reexports) = lib_binder.reexports.get(module_specifier)
                && let Some((source_module, original_name)) = file_reexports.get(member_name)
            {
                let name_to_lookup = original_name.as_deref().unwrap_or(member_name);
                return self.resolve_reexported_member(source_module, name_to_lookup, lib_binders);
            }
            // Then check lib binder's wildcard re-exports
            if let Some(source_modules) = lib_binder.wildcard_reexports.get(module_specifier) {
                for source_module in source_modules {
                    if let Some(sym_id) =
                        self.resolve_reexported_member(source_module, member_name, lib_binders)
                    {
                        return Some(sym_id);
                    }
                }
            }
        }

        None
    }

    /// Merge namespace exports into an object type for enum+namespace merging.
    ///
    /// When an enum and namespace are merged (same name), the namespace's exports
    /// become accessible as properties on the enum object.
    ///
    /// ## TypeScript Example:
    /// ```typescript
    /// enum Direction {
    ///   Up = 1,
    ///   Down = 2
    /// }
    /// namespace Direction {
    ///   export function isVertical(d: Direction): boolean {
    ///     return d === Direction.Up || d === Direction.Down;
    ///   }
    /// }
    /// // Direction.Up and Direction.isVertical() are both accessible
    /// ```
    pub(crate) fn merge_namespace_exports_into_object(
        &mut self,
        sym_id: SymbolId,
        _enum_type: TypeId,
    ) -> TypeId {
        use rustc_hash::FxHashMap;
        use tsz_solver::PropertyInfo;

        // Check recursion depth to prevent stack overflow
        const MAX_MERGE_DEPTH: u32 = 32;
        let depth = self.ctx.symbol_resolution_depth.get();
        if depth >= MAX_MERGE_DEPTH {
            return _enum_type; // Prevent infinite recursion in merge
        }

        let Some(symbol) = self.ctx.binder.get_symbol(sym_id) else {
            return _enum_type;
        };
        let Some(exports) = symbol.exports.as_ref() else {
            return _enum_type;
        };

        let mut props: FxHashMap<Atom, PropertyInfo> = FxHashMap::default();

        // Merge ALL exports from the symbol (enum members + namespace exports)
        // This allows accessing both enum members and namespace methods via EnumName.Member
        for (name, member_id) in exports.iter() {
            // Skip if this member is already being resolved (prevents infinite recursion)
            if self.ctx.symbol_resolution_set.contains(member_id) {
                continue; // Skip circular references
            }

            let Some(member_symbol) = self.ctx.binder.get_symbol(*member_id) else {
                continue;
            };
            use tsz_binder::symbol_flags;
            if member_symbol.flags & symbol_flags::VALUE == 0 {
                continue;
            }

            let mut type_id = self.get_type_of_symbol(*member_id);
            if member_symbol.flags & symbol_flags::INTERFACE != 0 {
                let mut candidate = self.type_of_value_declaration_for_symbol(
                    *member_id,
                    member_symbol.value_declaration,
                );
                if candidate == TypeId::UNKNOWN || candidate == TypeId::ERROR {
                    for &decl_idx in &member_symbol.declarations {
                        let cand = self.type_of_value_declaration_for_symbol(*member_id, decl_idx);
                        if cand != TypeId::UNKNOWN && cand != TypeId::ERROR {
                            candidate = cand;
                            break;
                        }
                    }
                }
                if candidate != TypeId::UNKNOWN && candidate != TypeId::ERROR {
                    type_id = candidate;
                }
            }
            let name_atom = self.ctx.types.intern_string(name);
            props.entry(name_atom).or_insert(PropertyInfo {
                name: name_atom,
                type_id,
                write_type: type_id,
                optional: false,
                readonly: false,
                is_method: false,
                visibility: Visibility::Public,
                parent_id: None,
            });
        }

        let properties: Vec<PropertyInfo> = props.into_values().collect();
        self.ctx.types.factory().object_with_flags_and_symbol(
            properties,
            tsz_solver::ObjectFlags::empty(),
            Some(sym_id),
        )
    }
}