formalang 0.0.5-beta

FormaLang compiler frontend: lexer, parser, semantic analyzer, and IR lowering.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Intermediate Representation (IR) for `FormaLang`
//!
//! The IR is a type-resolved representation of `FormaLang` programs optimized for
//! code generation. Unlike the AST which preserves source syntax, the IR provides:
//!
//! - Resolved types on every expression
//! - ID-based references to definitions (no string lookups)
//! - Flattened structure for easy traversal
//!
//! # Example
//!
//! ```
//! use formalang::compile_to_ir;
//!
//! let source = r#"
//! pub struct User {
//!     name: String,
//!     age: I32
//! }
//! "#;
//!
//! let module = compile_to_ir(source).unwrap();
//! assert_eq!(module.user_structs().count(), 1);
//! let user = module.user_structs().next().unwrap();
//! assert_eq!(user.name, "User");
//! ```

mod block;
mod closure_conv;
mod dce;
mod expr;
mod fold;
mod ids;
mod imports;
mod lower;
mod module;
mod monomorphise;
mod resolve_refs;
mod resolved_type;
mod span;
mod types;
mod visitor;

pub use block::{IrBlockStatement, IrMatchArm};
pub use closure_conv::ClosureConversionPass;
pub use dce::{
    eliminate_dead_code, eliminate_dead_code_expr, DeadCodeEliminationPass, DeadCodeEliminator,
};
pub use expr::{DispatchKind, IrExpr, ReferenceTarget};
pub use fold::{fold_constants, ConstantFolder, ConstantFoldingPass};
pub use ids::{
    BindingId, EnumId, FieldIdx, FunctionId, ImplId, LetId, MethodIdx, StructId, TraitId,
    VariantIdx,
};
pub use imports::{ImportedKind, IrImport, IrImportItem};
pub use lower::{lower_to_ir, lower_to_ir_with_path};
pub use module::{IrModule, IrModuleNode};
pub(crate) use monomorphise::walkers::walk_expr_children_mut;
pub use monomorphise::MonomorphisePass;
pub use resolve_refs::ResolveReferencesPass;
pub use resolved_type::{GenericBase, ResolvedType};
pub use span::{FileId, IrSpan};
pub use types::{
    ImplTarget, IrEnum, IrEnumVariant, IrField, IrFunction, IrFunctionParam, IrFunctionSig,
    IrGenericParam, IrImpl, IrLet, IrStruct, IrTrait, IrTraitRef,
};
pub use visitor::{
    walk_block_statement, walk_expr, walk_expr_children, walk_module, walk_module_children,
    IrVisitor,
};

use crate::ast::Visibility;

impl Visibility {
    /// Check if this visibility is public.
    #[must_use]
    pub const fn is_public(&self) -> bool {
        matches!(self, Self::Public)
    }
}

/// Extract the simple type name from a potentially module-qualified path.
///
/// Given a path like `alignment::Horizontal`, returns `Horizontal`.
/// For simple names like `Button`, returns the name unchanged.
///
/// # Example
///
/// ```
/// use formalang::ir::simple_type_name;
///
/// assert_eq!(simple_type_name("alignment::Horizontal"), "Horizontal");
/// assert_eq!(simple_type_name("Button"), "Button");
/// ```
#[must_use]
pub fn simple_type_name(name: &str) -> &str {
    name.rsplit("::").next().unwrap_or(name)
}