lehit 0.2.0

Embeddable Lehit language frontend and Cranelift JIT runtime
Documentation
//! Embedded `core://` source modules.
//!
//! The `.lt` files in this directory are the only source of truth for core
//! declarations and trait implementations. Rust code in this module only
//! assigns canonical paths and assembles those sources into a [`RustLib`].
//!
//! | Module | Responsibility |
//! | --- | --- |
//! | `core://primitive.lt` | primitive declarations and compiler intrinsics |
//! | `core://prelude.lt` | automatically resolved core aliases |
//! | `core://ops.lt`, `core://cmp.lt` | arithmetic and comparison traits |
//! | `core://clone.lt`, `core://drop.lt`, `core://deref.lt` | ownership traits |
//! | `core://box.lt`, `core://option.lt`, `core://non_zero.lt` | standard generic/value contracts |
//!
//! `/* compiler function */` marks a semantic intrinsic whose physical lowering
//! belongs to runtime codegen rather than an executable Lehit source body.

mod box_type;
mod clone;
mod cmp;
mod deref;
mod drop;
mod non_zero;
mod ops;
mod option_type;
mod prelude;
mod primitive;

pub use box_type::*;
pub use clone::*;
pub use cmp::*;
pub use deref::*;
pub use drop::*;
pub use non_zero::*;
pub use ops::*;
pub use option_type::*;
pub use prelude::*;
pub use primitive::*;

use crate::rust_lib::{RustLib, Script};

#[macro_export]
macro_rules! core_namespace {
    () => {
        "core://"
    };
}

pub use core_namespace;

pub const CORE_NAMESPACE_PATH: &str = core_namespace!();

/// Builds every embedded core module in unresolved source form.
///
/// The returned map currently contains ten canonical `core://` modules. The
/// runtime parses and resolves them through the same frontend used for host
/// source; no parallel Rust semantic declaration table is maintained.
pub fn generate_core_lib() -> RustLib {
    let mut library = RustLib::default();

    library.scripts.insert(
        CLONE_MODULE_FILE_PATH.to_string(),
        Script {
            content: CLONE_MODULE_FILE_CONTENT.to_string(),
            ..Script::default()
        },
    );
    library.scripts.insert(
        DEREF_MODULE_FILE_PATH.to_string(),
        Script {
            content: DEREF_MODULE_FILE_CONTENT.to_string(),
            ..Script::default()
        },
    );
    library.scripts.insert(
        DROP_MODULE_FILE_PATH.to_string(),
        Script {
            content: DROP_MODULE_FILE_CONTENT.to_string(),
            ..Script::default()
        },
    );
    library.scripts.insert(
        OPS_MODULE_FILE_PATH.to_string(),
        Script {
            content: OPS_MODULE_FILE_CONTENT.to_string(),
            ..Script::default()
        },
    );
    library.scripts.insert(
        CMP_MODULE_FILE_PATH.to_string(),
        Script {
            content: CMP_MODULE_FILE_CONTENT.to_string(),
            ..Script::default()
        },
    );
    library.scripts.insert(
        PRIMITIVE_MODULE_FILE_PATH.to_string(),
        generate_primitive_module(),
    );
    for (path, content) in [
        (NON_ZERO_MODULE_FILE_PATH, NON_ZERO_MODULE_FILE_CONTENT),
        (BOX_MODULE_FILE_PATH, BOX_MODULE_FILE_CONTENT),
        (OPTION_MODULE_FILE_PATH, OPTION_MODULE_FILE_CONTENT),
    ] {
        library.scripts.insert(
            path.to_string(),
            Script {
                content: content.to_string(),
                ..Script::default()
            },
        );
    }
    library.scripts.insert(
        PRELUDE_MODULE_FILE_PATH.to_string(),
        Script {
            content: PRELUDE_MODULE_FILE_CONTENT.to_string(),
            ..Script::default()
        },
    );

    library
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn concrete_non_zero_aliases_expand_to_generic_specializations() {
        use crate::parsing::{SourceFile, parse_file};
        use crate::semantic::{DeclarationIndex, ModuleGraph, SemanticType, TypeLowerer};

        let mut graph = ModuleGraph::default();
        for (path, script) in generate_core_lib().scripts {
            let parsed = parse_file(SourceFile {
                path: &path,
                text: &script.content,
            })
            .unwrap();
            graph
                .insert(&path, DeclarationIndex::collect(&parsed).unwrap())
                .unwrap();
        }
        graph.set_prelude(PRELUDE_MODULE_FILE_PATH).unwrap();
        let app_path = "app://non-zero-alias.lt";
        let app = parse_file(SourceFile {
            path: app_path,
            text: "acs make: fn() -> NonZeroU32",
        })
        .unwrap();
        graph
            .insert(app_path, DeclarationIndex::collect(&app).unwrap())
            .unwrap();
        let crate::parsing::ast::ContractSource::Declaration(function) =
            &app.ast.contract_definition_content.contract_accesses[0].source
        else {
            panic!("function declaration expected")
        };
        let crate::parsing::ast::ContractDeclarationKind::FunctionOnly(function) = &function.kind
        else {
            panic!("function contract expected")
        };
        let signature = TypeLowerer::new(&graph, &app, app_path)
            .lower_function(function)
            .unwrap();
        let SemanticType::Named(named) = signature.return_type.as_ref() else {
            panic!("NonZeroU32 must be a named specialization")
        };
        assert_eq!(named.path.module, NON_ZERO_MODULE_FILE_PATH);
        assert_eq!(named.path.local, "NonZero");
        assert!(matches!(
            named.generic_arguments.as_slice(),
            [crate::semantic::SemanticGenericArgument::Type(SemanticType::Named(argument))]
                if argument.path.module == PRIMITIVE_MODULE_FILE_PATH
                    && argument.path.local == "u32"
        ));
    }

    #[test]
    fn generic_box_extension_substitutes_its_deref_target() {
        use crate::parsing::{SourceFile, parse_file};
        use crate::semantic::{
            CanonicalSymbolPath, DeclarationIndex, ExtensionEnvironment, MethodTable, ModuleGraph,
            SemanticGenericArgument, SemanticNamedType, SemanticType,
        };

        let mut graph = ModuleGraph::default();
        for (path, script) in generate_core_lib().scripts {
            let parsed = parse_file(SourceFile {
                path: &path,
                text: &script.content,
            })
            .unwrap();
            graph
                .insert(&path, DeclarationIndex::collect(&parsed).unwrap())
                .unwrap();
        }
        graph.set_prelude(PRELUDE_MODULE_FILE_PATH).unwrap();
        let app = "app://box-deref-substitution.lt";
        let parsed = parse_file(SourceFile {
            path: app,
            text: "",
        })
        .unwrap();
        graph
            .insert(app, DeclarationIndex::collect(&parsed).unwrap())
            .unwrap();
        let u32_type = SemanticType::Named(SemanticNamedType {
            path: CanonicalSymbolPath {
                module: PRIMITIVE_MODULE_FILE_PATH.into(),
                local: "u32".into(),
            },
            generic_arguments: Vec::new(),
        });
        let boxed = SemanticNamedType {
            path: CanonicalSymbolPath {
                module: BOX_MODULE_FILE_PATH.into(),
                local: "Box".into(),
            },
            generic_arguments: vec![SemanticGenericArgument::Type(u32_type.clone())],
        };
        let environment = ExtensionEnvironment::build(&graph, app).unwrap();
        let table = MethodTable::build_named(&graph, &boxed, &environment).unwrap();
        let implementation = table
            .trait_implementations
            .iter()
            .find(|implementation| implementation.associated_types.contains_key("Target"))
            .unwrap();

        assert_eq!(
            implementation.concrete_associated_types.get("Target"),
            Some(&u32_type)
        );
    }

    #[test]
    fn generated_core_library_contains_prelude() {
        let library = generate_core_lib();
        let prelude = library
            .scripts
            .get(PRELUDE_MODULE_FILE_PATH)
            .expect("core prelude must be installed with RustLib");
        assert_eq!(prelude.content, PRELUDE_MODULE_FILE_CONTENT);
        assert!(library.scripts.contains_key(CLONE_MODULE_FILE_PATH));
        assert!(library.scripts.contains_key(DEREF_MODULE_FILE_PATH));
        assert!(library.scripts.contains_key(DROP_MODULE_FILE_PATH));
        assert!(library.scripts.contains_key(NON_ZERO_MODULE_FILE_PATH));
        assert!(library.scripts.contains_key(BOX_MODULE_FILE_PATH));
        assert!(library.scripts.contains_key(OPTION_MODULE_FILE_PATH));
    }
}