lisette_semantics/checker/infer/

mod.rs

pub(crate) mod addressability;
mod carry_mut;
mod context;
pub(crate) mod expressions;
mod interface;
mod unify;
mod validation;

pub use context::InferCtx;
pub(crate) use unify::BuiltinBound;

use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};

use super::freeze::FreezeFolder;
use super::{FileContextKind, TaskState};
use crate::store::Store;
use syntax::ast::Expression;
use syntax::program::{File, FileImport};

impl TaskState<'_> {
    /// Extract a module's `.lis` files from the store.
    pub fn take_module_files(&mut self, store: &mut Store, module_id: &str) -> Vec<File> {
        self.with_module_cursor(module_id, |_this| {
            let module = store
                .get_module_mut(module_id)
                .expect("module must exist for inference");
            std::mem::take(&mut module.files).into_values().collect()
        })
    }
}

impl InferCtx<'_, '_> {
    /// Infer types for `files` belonging to `module_id`.
    pub fn infer_module(&mut self, module_id: &str, files: Vec<File>) {
        let items_per_file: Vec<&[Expression]> = files.iter().map(|f| f.items.as_slice()).collect();
        self.check_const_cycles(&items_per_file);

        for file in files {
            self.infer_file(module_id, file);
        }
    }

    fn infer_file(&mut self, module_id: &str, file: File) {
        let store = self.store;
        let file_id = file.id;
        let imports = file.imports();

        self.with_file_context(
            store,
            module_id,
            file_id,
            &imports,
            FileContextKind::Standard,
            |this, store| {
                let mut ctx = InferCtx::new(this, store);
                ctx.check_definition_module_collisions(&file.items, &imports);

                let inferred_items: Vec<_> = file
                    .items
                    .into_iter()
                    .map(|item| {
                        let type_var = ctx.new_type_var();
                        ctx.infer_expression(item, &type_var)
                    })
                    .collect();

                ctx.check_reference_sibling_aliasing(&inferred_items);

                let frozen_items = {
                    let state = &mut *ctx;
                    let folder = FreezeFolder::new(&state.env);
                    folder.freeze_facts(&mut state.facts);
                    FreezeFolder::new(&state.env).freeze_items(inferred_items)
                };

                let typed_file = File {
                    id: file_id,
                    module_id: file.module_id,
                    name: file.name,
                    display_path: file.display_path,
                    source: file.source,
                    items: frozen_items,
                };

                ctx.typed_files.push((module_id.to_string(), typed_file));
            },
        );
    }

    fn check_definition_module_collisions(&mut self, items: &[Expression], imports: &[FileImport]) {
        let store = self.store;
        let alias_to_path: HashMap<String, String> = imports
            .iter()
            .filter_map(|imp| {
                imp.effective_alias(&store.go_package_names)
                    .map(|alias| (alias, imp.name.to_string()))
            })
            .collect();

        for item in items {
            let (definition_name, name_span) = match item {
                Expression::Function {
                    name, name_span, ..
                } => (name.as_str(), *name_span),
                Expression::Struct {
                    name, name_span, ..
                } => (name.as_str(), *name_span),
                Expression::Enum {
                    name, name_span, ..
                } => (name.as_str(), *name_span),
                Expression::TypeAlias {
                    name, name_span, ..
                } => (name.as_str(), *name_span),
                Expression::Const {
                    identifier,
                    identifier_span,
                    ..
                } => (identifier.as_str(), *identifier_span),
                Expression::Interface {
                    name, name_span, ..
                } => (name.as_str(), *name_span),
                _ => continue,
            };

            if let Some(import_path) = alias_to_path.get(definition_name) {
                self.sink
                    .push(diagnostics::infer::definition_shadows_import(
                        definition_name,
                        import_path,
                        name_span,
                    ));
            }
        }
    }

    pub(crate) fn register_block_local_items(&mut self, items: &[Expression]) {
        for item in items {
            match item {
                Expression::Const { .. } => self.register_block_local_const(item),
                Expression::Function { .. } => self.register_block_local_fn(item),
                _ => {}
            }
        }
    }

    fn register_block_local_const(&mut self, item: &Expression) {
        let store = self.store;
        let Expression::Const {
            identifier,
            identifier_span,
            annotation,
            expression,
            span,
            ..
        } = item
        else {
            return;
        };

        let qualified_name = self.qualify_name(identifier);
        let is_duplicate = self.scopes.lookup_const(identifier)
            || self.is_const_name(store, qualified_name.as_str());
        if is_duplicate && self.is_lis(store) {
            self.sink.push(diagnostics::infer::duplicate_definition(
                "constant",
                identifier,
                *identifier_span,
            ));
            return;
        }

        let before = self.sink.len();
        let const_ty = if let Some(annotation) = annotation {
            self.convert_to_type(store, annotation, span)
        } else {
            self.type_from_literal_expression(expression)
                .unwrap_or_else(|| self.new_type_var())
        };
        self.sink.truncate(before);

        let scope = self.scopes.current_mut();
        scope.values.insert(identifier.to_string(), const_ty);
        scope
            .consts
            .get_or_insert_with(HashSet::default)
            .insert(identifier.to_string());
    }

    fn register_block_local_fn(&mut self, item: &Expression) {
        let Expression::Function {
            name,
            generics,
            params,
            return_annotation,
            span,
            ..
        } = item
        else {
            return;
        };

        let store = self.store;
        let before = self.sink.len();
        let fn_ty = self.extract_signature_parts(store, generics, params, return_annotation, span);
        self.sink.truncate(before);

        let scope = self.scopes.current_mut();
        scope.values.insert(name.to_string(), fn_ty);
    }
}