teascade/reid-llvm
1
0
Fork 0
Code Issues Pull Requests Packages Releases 4 Wiki Activity

Add module_id for modules and metadata

Browse Source
This commit is contained in:
Sofia 2025-07-17 14:56:41 +03:00
parent e2dc1a3f85
commit 64e34ecf13
10 changed files with 135 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
reid/examples/testcodegen.rs
View File

@ -161,6 +161,7 @@ fn main() {
let mir_context = mir::Context { let mir_context = mir::Context {
modules: vec![Module { modules: vec![Module {
name: "test module".to_owned(), name: "test module".to_owned(),
module_id: SourceModuleId::default(),
imports: vec![], imports: vec![],
functions: vec![fibonacci, main], functions: vec![fibonacci, main],
typedefs: Vec::new(), typedefs: Vec::new(),

74
reid/src/ast/process.rs
View File

@ -2,7 +2,7 @@ use std::path::PathBuf;
use crate::{ use crate::{
ast::{self}, ast::{self},
mir::{self, NamedVariableRef, StmtKind, StructField, StructType}, mir::{self, NamedVariableRef, SourceModuleId, StmtKind, StructField, StructType},
}; };
impl mir::Context { impl mir::Context {
@ -12,7 +12,7 @@ impl mir::Context {
} }
impl ast::Module { impl ast::Module {
pub fn process(&self) -> mir::Module { pub fn process(&self, module_id: SourceModuleId) -> mir::Module {
let mut imports = Vec::new(); let mut imports = Vec::new();
let mut functions = Vec::new(); let mut functions = Vec::new();
let mut typedefs = Vec::new(); let mut typedefs = Vec::new();
@ -21,7 +21,7 @@ impl ast::Module {
for stmt in &self.top_level_statements { for stmt in &self.top_level_statements {
match stmt { match stmt {
Import(import) => { Import(import) => {
imports.push(mir::Import(import.0.clone(), import.1.into())); imports.push(mir::Import(import.0.clone(), import.1.as_meta(module_id)));
} }
FunctionDefinition(ast::FunctionDefinition(signature, is_pub, block, range)) => { FunctionDefinition(ast::FunctionDefinition(signature, is_pub, block, range)) => {
let def = mir::FunctionDefinition { let def = mir::FunctionDefinition {
@ -39,7 +39,10 @@ impl ast::Module {
.cloned() .cloned()
.map(|p| (p.0, p.1.into())) .map(|p| (p.0, p.1.into()))
.collect(), .collect(),
kind: mir::FunctionDefinitionKind::Local(block.into_mir(), (*range).into()), kind: mir::FunctionDefinitionKind::Local(
block.into_mir(module_id),
(*range).as_meta(module_id),
),
}; };
functions.push(def); functions.push(def);
} }
@ -75,14 +78,14 @@ impl ast::Module {
StructField( StructField(
s.name.clone(), s.name.clone(),
s.ty.clone().into(), s.ty.clone().into(),
s.range.into(), s.range.as_meta(module_id),
) )
}) })
.collect(), .collect(),
)) ))
} }
}, },
meta: (*range).into(), meta: (*range).as_meta(module_id),
}; };
typedefs.push(def); typedefs.push(def);
} }
@ -91,6 +94,7 @@ impl ast::Module {
mir::Module { mir::Module {
name: self.name.clone(), name: self.name.clone(),
module_id: module_id,
imports, imports,
functions, functions,
path: self.path.clone(), path: self.path.clone(),
@ -101,7 +105,7 @@ impl ast::Module {
} }
impl ast::Block { impl ast::Block {
pub fn into_mir(&self) -> mir::Block { pub fn into_mir(&self, module_id: SourceModuleId) -> mir::Block {
let mut mir_statements = Vec::new(); let mut mir_statements = Vec::new();
for statement in &self.0 { for statement in &self.0 {
@ -115,27 +119,31 @@ impl ast::Block {
.map(|t| t.0.into()) .map(|t| t.0.into())
.unwrap_or(mir::TypeKind::Vague(mir::VagueType::Unknown)), .unwrap_or(mir::TypeKind::Vague(mir::VagueType::Unknown)),
s_let.0.clone(), s_let.0.clone(),
s_let.4.into(), s_let.4.as_meta(module_id),
), ),
s_let.2, s_let.2,
s_let.3.process(), s_let.3.process(module_id),
), ),
s_let.4, s_let.4,
), ),
ast::BlockLevelStatement::Set(var_ref, expression, range) => ( ast::BlockLevelStatement::Set(var_ref, expression, range) => (
StmtKind::Set(var_ref.process(), expression.process()), StmtKind::Set(var_ref.process(module_id), expression.process(module_id)),
*range, *range,
), ),
ast::BlockLevelStatement::Import { _i } => todo!(), ast::BlockLevelStatement::Import { _i } => todo!(),
ast::BlockLevelStatement::Expression(e) => (StmtKind::Expression(e.process()), e.1), ast::BlockLevelStatement::Expression(e) => {
ast::BlockLevelStatement::Return(_, e) => (StmtKind::Expression(e.process()), e.1), (StmtKind::Expression(e.process(module_id)), e.1)
}
ast::BlockLevelStatement::Return(_, e) => {
(StmtKind::Expression(e.process(module_id)), e.1)
}
}; };
mir_statements.push(mir::Statement(kind, range.into())); mir_statements.push(mir::Statement(kind, range.as_meta(module_id)));
} }
let return_expression = if let Some(r) = &self.1 { let return_expression = if let Some(r) = &self.1 {
Some((r.0.into(), Box::new(r.1.process()))) Some((r.0.into(), Box::new(r.1.process(module_id))))
} else { } else {
None None
}; };
@ -143,7 +151,7 @@ impl ast::Block {
mir::Block { mir::Block {
statements: mir_statements, statements: mir_statements,
return_expression, return_expression,
meta: self.2.into(), meta: self.2.as_meta(module_id),
} }
} }
} }
@ -158,61 +166,67 @@ impl From<ast::ReturnType> for mir::ReturnKind {
} }
impl ast::Expression { impl ast::Expression {
fn process(&self) -> mir::Expression { fn process(&self, module_id: SourceModuleId) -> mir::Expression {
let kind = match &self.0 { let kind = match &self.0 {
ast::ExpressionKind::VariableName(name) => mir::ExprKind::Variable(NamedVariableRef( ast::ExpressionKind::VariableName(name) => mir::ExprKind::Variable(NamedVariableRef(
mir::TypeKind::Vague(mir::VagueType::Unknown), mir::TypeKind::Vague(mir::VagueType::Unknown),
name.clone(), name.clone(),
self.1.into(), self.1.as_meta(module_id),
)), )),
ast::ExpressionKind::Literal(literal) => mir::ExprKind::Literal(literal.mir()), ast::ExpressionKind::Literal(literal) => mir::ExprKind::Literal(literal.mir()),
ast::ExpressionKind::Binop(binary_operator, lhs, rhs) => mir::ExprKind::BinOp( ast::ExpressionKind::Binop(binary_operator, lhs, rhs) => mir::ExprKind::BinOp(
binary_operator.mir(), binary_operator.mir(),
Box::new(lhs.process()), Box::new(lhs.process(module_id)),
Box::new(rhs.process()), Box::new(rhs.process(module_id)),
), ),
ast::ExpressionKind::FunctionCall(fn_call_expr) => { ast::ExpressionKind::FunctionCall(fn_call_expr) => {
mir::ExprKind::FunctionCall(mir::FunctionCall { mir::ExprKind::FunctionCall(mir::FunctionCall {
name: fn_call_expr.0.clone(), name: fn_call_expr.0.clone(),
return_type: mir::TypeKind::Vague(mir::VagueType::Unknown), return_type: mir::TypeKind::Vague(mir::VagueType::Unknown),
parameters: fn_call_expr.1.iter().map(|e| e.process()).collect(), parameters: fn_call_expr
.1
.iter()
.map(|e| e.process(module_id))
.collect(),
}) })
} }
ast::ExpressionKind::BlockExpr(block) => mir::ExprKind::Block(block.into_mir()), ast::ExpressionKind::BlockExpr(block) => {
mir::ExprKind::Block(block.into_mir(module_id))
}
ast::ExpressionKind::IfExpr(if_expression) => { ast::ExpressionKind::IfExpr(if_expression) => {
let cond = if_expression.0.process(); let cond = if_expression.0.process(module_id);
let then_block = if_expression.1.into_mir(); let then_block = if_expression.1.into_mir(module_id);
let else_block = if let Some(el) = &if_expression.2 { let else_block = if let Some(el) = &if_expression.2 {
Some(el.into_mir()) Some(el.into_mir(module_id))
} else { } else {
None None
}; };
mir::ExprKind::If(mir::IfExpression(Box::new(cond), then_block, else_block)) mir::ExprKind::If(mir::IfExpression(Box::new(cond), then_block, else_block))
} }
ast::ExpressionKind::Array(expressions) => { ast::ExpressionKind::Array(expressions) => {
mir::ExprKind::Array(expressions.iter().map(|e| e.process()).collect()) mir::ExprKind::Array(expressions.iter().map(|e| e.process(module_id)).collect())
} }
ast::ExpressionKind::Indexed(expression, idx_expr) => mir::ExprKind::Indexed( ast::ExpressionKind::Indexed(expression, idx_expr) => mir::ExprKind::Indexed(
Box::new(expression.process()), Box::new(expression.process(module_id)),
mir::TypeKind::Vague(mir::VagueType::Unknown), mir::TypeKind::Vague(mir::VagueType::Unknown),
Box::new(idx_expr.process()), Box::new(idx_expr.process(module_id)),
), ),
ast::ExpressionKind::StructExpression(struct_init) => mir::ExprKind::Struct( ast::ExpressionKind::StructExpression(struct_init) => mir::ExprKind::Struct(
struct_init.name.clone(), struct_init.name.clone(),
struct_init struct_init
.fields .fields
.iter() .iter()
.map(|(n, e)| (n.clone(), e.process())) .map(|(n, e)| (n.clone(), e.process(module_id)))
.collect(), .collect(),
), ),
ast::ExpressionKind::Accessed(expression, name) => mir::ExprKind::Accessed( ast::ExpressionKind::Accessed(expression, name) => mir::ExprKind::Accessed(
Box::new(expression.process()), Box::new(expression.process(module_id)),
mir::TypeKind::Vague(mir::VagueType::Unknown), mir::TypeKind::Vague(mir::VagueType::Unknown),
name.clone(), name.clone(),
), ),
}; };
mir::Expression(kind, self.1.into()) mir::Expression(kind, self.1.as_meta(module_id))
} }
} }

0
reid/src/error_raporting.rs Normal file
View File

5
reid/src/lib.rs
View File

@ -45,6 +45,7 @@ use std::path::PathBuf;
use mir::{ use mir::{
linker::LinkerPass, typecheck::TypeCheck, typeinference::TypeInference, typerefs::TypeRefs, linker::LinkerPass, typecheck::TypeCheck, typeinference::TypeInference, typerefs::TypeRefs,
SourceModuleId,
}; };
use reid_lib::{compile::CompileOutput, Context}; use reid_lib::{compile::CompileOutput, Context};
@ -75,6 +76,7 @@ pub enum ReidError {
pub fn compile_module( pub fn compile_module(
source: &str, source: &str,
name: String, name: String,
module_id: SourceModuleId,
path: Option<PathBuf>, path: Option<PathBuf>,
is_main: bool, is_main: bool,
) -> Result<mir::Module, ReidError> { ) -> Result<mir::Module, ReidError> {
@ -99,7 +101,7 @@ pub fn compile_module(
is_main, is_main,
}; };
Ok(ast_module.process()) Ok(ast_module.process(module_id))
} }
pub fn perform_all_passes(context: &mut mir::Context) -> Result<(), ReidError> { pub fn perform_all_passes(context: &mut mir::Context) -> Result<(), ReidError> {
@ -159,6 +161,7 @@ pub fn compile(source: &str, path: PathBuf) -> Result<CompileOutput, ReidError>
vec![compile_module( vec![compile_module(
source, source,
path.file_name().unwrap().to_str().unwrap().to_owned(), path.file_name().unwrap().to_str().unwrap().to_owned(),
SourceModuleId::default(),
Some(path.clone()), Some(path.clone()),
true, true,
)?], )?],

8
reid/src/mir/display.rs
View File

@ -289,7 +289,13 @@ impl Display for CmpOperator {
impl Display for Metadata { impl Display for Metadata {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self.range) write!(f, "{:?} ({})", self.range, self.source_module_id)
}
}
impl Display for SourceModuleId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Mod {}", self.0)
} }
} }

6
reid/src/mir/impl.rs
View File

@ -1,4 +1,8 @@
use super::{typecheck::ErrorKind, typerefs::TypeRefs, VagueType as Vague, *}; use super::{
typecheck::ErrorKind,
typerefs::{ScopeTypeRefs, TypeRef, TypeRefs},
VagueType as Vague, *,
};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum ReturnTypeOther { pub enum ReturnTypeOther {

32
reid/src/mir/linker.rs
View File

@ -12,7 +12,7 @@ use crate::{compile_module, ReidError};
use super::{ use super::{
pass::{Pass, PassState}, pass::{Pass, PassState},
r#impl::EqualsIssue, r#impl::EqualsIssue,
Context, FunctionDefinition, Import, Metadata, Module, Context, FunctionDefinition, Import, Metadata, Module, SourceModuleId,
}; };
pub static STD_SOURCE: &str = include_str!("../../lib/std.reid"); pub static STD_SOURCE: &str = include_str!("../../lib/std.reid");
@ -41,8 +41,15 @@ pub enum ErrorKind {
FunctionIsPrivate(String, String), FunctionIsPrivate(String, String),
} }
pub fn compile_std() -> super::Module { pub fn compile_std(module_id: SourceModuleId) -> super::Module {
let module = compile_module(STD_SOURCE, "standard_library".to_owned(), None, false).unwrap(); let module = compile_module(
STD_SOURCE,
"standard_library".to_owned(),
module_id,
None,
false,
)
.unwrap();
let mut mir_context = super::Context::from(vec![module], Default::default()); let mut mir_context = super::Context::from(vec![module], Default::default());
@ -85,7 +92,16 @@ impl Pass for LinkerPass {
modules.insert(module.name.clone(), Rc::new(RefCell::new(module))); modules.insert(module.name.clone(), Rc::new(RefCell::new(module)));
} }
modules.insert("std".to_owned(), Rc::new(RefCell::new(compile_std()))); let mut module_counter = modules
.values()
.map(|m| m.borrow().module_id)
.max()
.unwrap();
modules.insert(
"std".to_owned(),
Rc::new(RefCell::new(compile_std(module_counter.increment()))),
);
let mut modules_to_process: Vec<Rc<RefCell<Module>>> = modules.values().cloned().collect(); let mut modules_to_process: Vec<Rc<RefCell<Module>>> = modules.values().cloned().collect();
@ -117,7 +133,13 @@ impl Pass for LinkerPass {
continue; continue;
}; };
match compile_module(&source, module_name.clone(), Some(file_path), false) { match compile_module(
&source,
module_name.clone(),
module_counter.increment(),
Some(file_path),
false,
) {
Ok(imported_module) => { Ok(imported_module) => {
if imported_module.is_main { if imported_module.is_main {
state.ok::<_, Infallible>( state.ok::<_, Infallible>(

27
reid/src/mir/mod.rs
View File

@ -14,24 +14,40 @@ pub mod typecheck;
pub mod typeinference; pub mod typeinference;
pub mod typerefs; pub mod typerefs;
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Default, Hash)]
pub struct SourceModuleId(u32);
impl SourceModuleId {
pub fn increment(&mut self) -> SourceModuleId {
self.0 += 1;
SourceModuleId(self.0)
}
}
#[derive(Debug, Default, Clone, Copy)] #[derive(Debug, Default, Clone, Copy)]
pub struct Metadata { pub struct Metadata {
pub range: TokenRange, pub range: TokenRange,
pub source_module_id: SourceModuleId,
} }
impl std::ops::Add for Metadata { impl std::ops::Add for Metadata {
type Output = Metadata; type Output = Metadata;
fn add(self, rhs: Self) -> Self::Output { fn add(self, rhs: Self) -> Self::Output {
assert!(self.source_module_id == rhs.source_module_id);
Metadata { Metadata {
range: self.range + rhs.range, range: self.range + rhs.range,
source_module_id: self.source_module_id,
} }
} }
} }
impl From<TokenRange> for Metadata { impl TokenRange {
fn from(value: TokenRange) -> Self { pub fn as_meta(self, module: SourceModuleId) -> Metadata {
Metadata { range: value } Metadata {
range: self,
source_module_id: module,
}
} }
} }
@ -240,14 +256,14 @@ pub enum FunctionDefinitionKind {
impl FunctionDefinition { impl FunctionDefinition {
fn block_meta(&self) -> Metadata { fn block_meta(&self) -> Metadata {
match &self.kind { match &self.kind {
FunctionDefinitionKind::Local(block, _) => block.meta, FunctionDefinitionKind::Local(block, _) => block.meta.clone(),
FunctionDefinitionKind::Extern(_) => Metadata::default(), FunctionDefinitionKind::Extern(_) => Metadata::default(),
} }
} }
fn signature(&self) -> Metadata { fn signature(&self) -> Metadata {
match &self.kind { match &self.kind {
FunctionDefinitionKind::Local(_, metadata) => *metadata, FunctionDefinitionKind::Local(_, metadata) => metadata.clone(),
FunctionDefinitionKind::Extern(_) => Metadata::default(), FunctionDefinitionKind::Extern(_) => Metadata::default(),
} }
} }
@ -288,6 +304,7 @@ pub enum TypeDefinitionKind {
#[derive(Debug)] #[derive(Debug)]
pub struct Module { pub struct Module {
pub name: String, pub name: String,
pub module_id: SourceModuleId,
pub imports: Vec<Import>, pub imports: Vec<Import>,
pub functions: Vec<FunctionDefinition>, pub functions: Vec<FunctionDefinition>,
pub typedefs: Vec<TypeDefinition>, pub typedefs: Vec<TypeDefinition>,

26
reid/tests/e2e.rs
View File

@ -15,7 +15,13 @@ pub static STRINGS: &str = include_str!("../../reid_src/strings.reid");
#[test] #[test]
fn array_compiles_well() { fn array_compiles_well() {
let module = assert_err(compile_module(ARRAY, "array".to_owned(), None, true)); let module = assert_err(compile_module(
ARRAY,
"array".to_owned(),
Default::default(),
None,
true,
));
assert_err(perform_all_passes(&mut mir::Context { assert_err(perform_all_passes(&mut mir::Context {
modules: vec![module], modules: vec![module],
@ -28,6 +34,7 @@ fn fibonacci_compiles_well() {
let module = assert_err(compile_module( let module = assert_err(compile_module(
FIBONACCI, FIBONACCI,
"fibonacci".to_owned(), "fibonacci".to_owned(),
Default::default(),
None, None,
true, true,
)); ));
@ -43,6 +50,7 @@ fn hello_world_compiles_well() {
let module = assert_err(compile_module( let module = assert_err(compile_module(
HELLO_WORLD, HELLO_WORLD,
"hello_world".to_owned(), "hello_world".to_owned(),
Default::default(),
None, None,
true, true,
)); ));
@ -55,7 +63,13 @@ fn hello_world_compiles_well() {
#[test] #[test]
fn mutable_compiles_well() { fn mutable_compiles_well() {
let module = assert_err(compile_module(MUTABLE, "mutable".to_owned(), None, true)); let module = assert_err(compile_module(
MUTABLE,
"mutable".to_owned(),
Default::default(),
None,
true,
));
assert_err(perform_all_passes(&mut mir::Context { assert_err(perform_all_passes(&mut mir::Context {
modules: vec![module], modules: vec![module],
@ -65,7 +79,13 @@ fn mutable_compiles_well() {
#[test] #[test]
fn strings_compiles_well() { fn strings_compiles_well() {
let module = assert_err(compile_module(STRINGS, "strings".to_owned(), None, true)); let module = assert_err(compile_module(
STRINGS,
"strings".to_owned(),
Default::default(),
None,
true,
));
assert_err(perform_all_passes(&mut mir::Context { assert_err(perform_all_passes(&mut mir::Context {
modules: vec![module], modules: vec![module],

4
reid/tests/stdlib.rs
View File

@ -8,12 +8,12 @@ mod util;
#[test] #[test]
fn compiles() { fn compiles() {
let _ = compile_std(); let _ = compile_std(Default::default());
} }
#[test] #[test]
fn passes_all_passes() { fn passes_all_passes() {
let mut std = compile_std(); let mut std = compile_std(Default::default());
// Needed to pass linker-pass // Needed to pass linker-pass
std.is_main = true; std.is_main = true;