shadowcat/lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BRANCHING (TURING COMPLETE????)

Browse Source
This commit is contained in:
shadow cat
2025-03-29 15:08:15 -04:00
parent 021434d2f1
commit f57af3b2b5
25 changed files with 780 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/ir/lower/func.rs
View File

@@ -47,4 +47,12 @@ pub enum IRLInstruction {
Ret {
src: VarID,
},
// TODO I feel like this should be turned into control flow instructions, maybe...
// not sure but LLVM has them so might be right play; seems optimal for optimization
Jump(Symbol),
Branch {
to: Symbol,
cond: VarID,
},
Mark(Symbol),
}

398
src/ir/lower/program.rs
View File

@@ -1,8 +1,11 @@
use std::collections::HashMap;
use crate::ir::SymbolSpace;
use crate::ir::{IRUFunction, IRUInstrInst, Size, SymbolSpace};
use super::{IRLFunction, IRLInstruction, IRUInstruction, IRUProgram, Len, Symbol, Type, VarID};
use super::{
IRLFunction, IRLInstruction, IRUInstruction, IRUProgram, Len, Symbol, SymbolSpaceBuilder, Type,
VarID,
};
pub struct IRLProgram {
sym_space: SymbolSpace,
@@ -20,179 +23,18 @@ impl IRLProgram {
}
}
let start = start.ok_or("no start method found")?;
let mut builder = SymbolSpace::with_entries(&[start]);
let entry = builder.func(&start);
while let Some((sym, i)) = builder.pop_fn() {
let mut ssbuilder = SymbolSpaceBuilder::with_entries(&[start]);
let entry = ssbuilder.func(&start);
while let Some((sym, i)) = ssbuilder.pop_fn() {
let f = p.fns[i.0].as_ref().unwrap();
let mut instrs = Vec::new();
let mut stack = HashMap::new();
let mut makes_call = false;
let mut alloc_stack = |i: VarID| -> bool {
let size = *stack
.entry(i)
.or_insert(p.size_of_var(i).expect("unsized type"));
size == 0
};
let mut fbuilder = IRLFunctionBuilder::new(p, &mut ssbuilder);
for i in &f.instructions {
match &i.i {
IRUInstruction::Mv { dest, src } => {
if alloc_stack(dest.id) {
continue;
}
instrs.push(IRLInstruction::Mv {
dest: dest.id,
dest_offset: 0,
src: src.id,
src_offset: 0,
});
}
IRUInstruction::Ref { dest, src } => {
if alloc_stack(dest.id) {
continue;
}
instrs.push(IRLInstruction::Ref {
dest: dest.id,
src: src.id,
});
}
IRUInstruction::LoadData { dest, src } => {
if alloc_stack(dest.id) {
continue;
}
let data = &p.data[src.0];
let ddef = p.get_data(*src);
let sym = builder.ro_data(src, data, Some(ddef.label.clone()));
instrs.push(IRLInstruction::LoadData {
dest: dest.id,
offset: 0,
len: data.len() as Len,
src: sym,
});
}
IRUInstruction::LoadSlice { dest, src } => {
if alloc_stack(dest.id) {
continue;
}
let data = &p.data[src.0];
let def = p.get_data(*src);
let Type::Array(ty, len) = &def.ty else {
return Err(format!("tried to load {} as slice", p.type_name(&def.ty)));
};
let sym = builder.ro_data(src, data, Some(def.label.clone()));
instrs.push(IRLInstruction::LoadAddr {
dest: dest.id,
offset: 0,
src: sym,
});
let sym = builder.anon_ro_data(
&(*len as u64).to_le_bytes(),
Some(format!("len: {}", len)),
);
instrs.push(IRLInstruction::LoadData {
dest: dest.id,
offset: 8,
len: 8,
src: sym,
});
}
IRUInstruction::LoadFn { dest, src } => {
if alloc_stack(dest.id) {
continue;
}
let sym = builder.func(src);
instrs.push(IRLInstruction::LoadAddr {
dest: dest.id,
offset: 0,
src: sym,
});
}
IRUInstruction::Call { dest, f, args } => {
alloc_stack(dest.id);
makes_call = true;
let fid = &p.fn_map[&f.id];
let sym = builder.func(fid);
let ret_size = p.size_of_var(dest.id).expect("unsized type");
let dest = if ret_size > 0 {
Some((dest.id, ret_size))
} else {
None
};
instrs.push(IRLInstruction::Call {
dest,
f: sym,
args: args
.iter()
.map(|a| (a.id, p.size_of_var(a.id).expect("unsized type")))
.collect(),
});
}
IRUInstruction::AsmBlock { instructions, args } => {
instrs.push(IRLInstruction::AsmBlock {
instructions: instructions.clone(),
args: args.iter().cloned().map(|(r, v)| (r, v.id)).collect(),
})
}
IRUInstruction::Ret { src } => instrs.push(IRLInstruction::Ret { src: src.id }),
IRUInstruction::Construct { dest, fields } => {
if alloc_stack(dest.id) {
continue;
}
let ty = &p.get_var(dest.id).ty;
let Type::Concrete(id) = ty else {
return Err(format!("Failed to contruct type {}", p.type_name(ty)));
};
let struc = p.get_struct(*id);
for (name, var) in fields {
instrs.push(IRLInstruction::Mv {
dest: dest.id,
src: var.id,
dest_offset: struc.fields[name].offset,
src_offset: 0,
})
}
}
IRUInstruction::Access { dest, src, field } => {
if alloc_stack(dest.id) {
continue;
}
let ty = &p.get_var(src.id).ty;
let Type::Concrete(id) = ty else {
return Err(format!(
"Failed to access field of struct {}",
p.type_name(ty)
));
};
let struc = p.get_struct(*id);
let Some(field) = struc.fields.get(field) else {
return Err(format!("No field {field} in struct {}", p.type_name(ty)));
};
instrs.push(IRLInstruction::Mv {
dest: dest.id,
src: src.id,
src_offset: field.offset,
dest_offset: 0,
})
}
};
fbuilder.insert_instr(i);
}
builder.write_fn(
sym,
IRLFunction {
instructions: instrs,
makes_call,
args: f
.args
.iter()
.map(|a| (*a, p.size_of_var(*a).expect("unsized type")))
.collect(),
ret_size: p.size_of_type(&f.ret).expect("unsized type"),
stack,
},
Some(f.name.clone()),
);
let res = fbuilder.finish(f);
ssbuilder.write_fn(sym, res, Some(f.name.clone()));
}
let sym_space = builder.finish().expect("we failed the mission");
let sym_space = ssbuilder.finish().expect("we failed the mission");
Ok(Self { sym_space, entry })
}
@@ -201,6 +43,220 @@ impl IRLProgram {
}
}
pub struct IRLFunctionBuilder<'a> {
program: &'a IRUProgram,
builder: &'a mut SymbolSpaceBuilder,
instrs: Vec<IRLInstruction>,
stack: HashMap<VarID, Size>,
makes_call: bool,
outer: Option<Symbol>,
}
impl<'a> IRLFunctionBuilder<'a> {
pub fn new(program: &'a IRUProgram, builder: &'a mut SymbolSpaceBuilder) -> Self {
Self {
instrs: Vec::new(),
stack: HashMap::new(),
makes_call: false,
program,
builder,
outer: None,
}
}
pub fn alloc_stack(&mut self, i: VarID) -> Option<()> {
let size = *self
.stack
.entry(i)
.or_insert(self.program.size_of_var(i).expect("unsized type"));
if size == 0 {
None
} else {
Some(())
}
}
pub fn insert_instr(&mut self, i: &IRUInstrInst) -> Option<Option<String>> {
match &i.i {
IRUInstruction::Mv { dest, src } => {
self.alloc_stack(dest.id)?;
self.instrs.push(IRLInstruction::Mv {
dest: dest.id,
dest_offset: 0,
src: src.id,
src_offset: 0,
});
}
IRUInstruction::Ref { dest, src } => {
self.alloc_stack(dest.id)?;
self.instrs.push(IRLInstruction::Ref {
dest: dest.id,
src: src.id,
});
}
IRUInstruction::LoadData { dest, src } => {
self.alloc_stack(dest.id)?;
let data = &self.program.data[src.0];
let ddef = self.program.get_data(*src);
let sym = self.builder.ro_data(src, data, Some(ddef.label.clone()));
self.instrs.push(IRLInstruction::LoadData {
dest: dest.id,
offset: 0,
len: data.len() as Len,
src: sym,
});
}
IRUInstruction::LoadSlice { dest, src } => {
self.alloc_stack(dest.id)?;
let data = &self.program.data[src.0];
let def = self.program.get_data(*src);
let Type::Array(_, len) = &def.ty else {
return Some(Some(format!(
"tried to load {} as slice",
self.program.type_name(&def.ty)
)));
};
let sym = self.builder.ro_data(src, data, Some(def.label.clone()));
self.instrs.push(IRLInstruction::LoadAddr {
dest: dest.id,
offset: 0,
src: sym,
});
let sym = self
.builder
.anon_ro_data(&(*len as u64).to_le_bytes(), Some(format!("len: {}", len)));
self.instrs.push(IRLInstruction::LoadData {
dest: dest.id,
offset: 8,
len: 8,
src: sym,
});
}
IRUInstruction::LoadFn { dest, src } => {
self.alloc_stack(dest.id)?;
let sym = self.builder.func(src);
self.instrs.push(IRLInstruction::LoadAddr {
dest: dest.id,
offset: 0,
src: sym,
});
}
IRUInstruction::Call { dest, f, args } => {
self.alloc_stack(dest.id);
self.makes_call = true;
let fid = &self.program.fn_map[&f.id];
let sym = self.builder.func(fid);
let ret_size = self.program.size_of_var(dest.id).expect("unsized type");
let dest = if ret_size > 0 {
Some((dest.id, ret_size))
} else {
None
};
self.instrs.push(IRLInstruction::Call {
dest,
f: sym,
args: args
.iter()
.map(|a| (a.id, self.program.size_of_var(a.id).expect("unsized type")))
.collect(),
});
}
IRUInstruction::AsmBlock { instructions, args } => {
self.instrs.push(IRLInstruction::AsmBlock {
instructions: instructions.clone(),
args: args.iter().cloned().map(|(r, v)| (r, v.id)).collect(),
})
}
IRUInstruction::Ret { src } => self.instrs.push(IRLInstruction::Ret { src: src.id }),
IRUInstruction::Construct { dest, fields } => {
self.alloc_stack(dest.id)?;
let ty = &self.program.get_var(dest.id).ty;
let Type::Concrete(id) = ty else {
return Some(Some(format!(
"Failed to contruct type {}",
self.program.type_name(ty)
)));
};
let struc = self.program.get_struct(*id);
for (name, var) in fields {
self.instrs.push(IRLInstruction::Mv {
dest: dest.id,
src: var.id,
dest_offset: struc.fields[name].offset,
src_offset: 0,
})
}
}
IRUInstruction::Access { dest, src, field } => {
self.alloc_stack(dest.id)?;
let ty = &self.program.get_var(src.id).ty;
let Type::Concrete(id) = ty else {
return Some(Some(format!(
"Failed to access field of struct {}",
self.program.type_name(ty)
)));
};
let struc = self.program.get_struct(*id);
let Some(field) = struc.fields.get(field) else {
return Some(Some(format!(
"No field {field} in struct {}",
self.program.type_name(ty)
)));
};
self.instrs.push(IRLInstruction::Mv {
dest: dest.id,
src: src.id,
src_offset: field.offset,
dest_offset: 0,
})
}
IRUInstruction::If { cond, body } => {
let sym = self.builder.reserve();
self.instrs.push(IRLInstruction::Branch {
to: *sym,
cond: cond.id,
});
for i in body {
self.insert_instr(i);
}
self.instrs.push(IRLInstruction::Mark(*sym));
}
IRUInstruction::Loop { body } => {
let top = self.builder.reserve();
let bot = self.builder.reserve();
let old = self.outer;
self.outer = Some(*bot);
self.instrs.push(IRLInstruction::Mark(*top));
for i in body {
self.insert_instr(i);
}
self.instrs.push(IRLInstruction::Jump(*top));
self.instrs.push(IRLInstruction::Mark(*bot));
self.outer = old;
}
IRUInstruction::Break => {
self.instrs.push(IRLInstruction::Jump(
self.outer.expect("Tried to break outside of loop"),
));
}
};
Some(None)
}
pub fn finish(self, f: &IRUFunction) -> IRLFunction {
IRLFunction {
instructions: self.instrs,
makes_call: self.makes_call,
args: f
.args
.iter()
.map(|a| (*a, self.program.size_of_var(*a).expect("unsized type")))
.collect(),
ret_size: self.program.size_of_type(&f.ret).expect("unsized type"),
stack: self.stack,
}
}
}
impl std::ops::Deref for IRLProgram {
type Target = SymbolSpace;

41
src/ir/lower/symbol.rs
View File

@@ -18,6 +18,7 @@ impl std::ops::Deref for WritableSymbol {
pub struct SymbolSpace {
ro_data: Vec<(Symbol, Vec<u8>)>,
fns: Vec<(Symbol, IRLFunction)>,
len: usize,
labels: Vec<Option<String>>,
}
@@ -32,21 +33,6 @@ pub struct SymbolSpaceBuilder {
}
impl SymbolSpace {
pub fn with_entries(entries: &[FnID]) -> SymbolSpaceBuilder {
let mut s = SymbolSpaceBuilder {
symbols: 0,
unwritten_fns: Vec::new(),
fn_map: HashMap::new(),
data_map: HashMap::new(),
ro_data: Vec::new(),
fns: Vec::new(),
labels: Vec::new(),
};
for e in entries {
s.func(e);
}
s
}
pub fn ro_data(&self) -> &[(Symbol, Vec<u8>)] {
&self.ro_data
}
@@ -56,9 +42,30 @@ impl SymbolSpace {
pub fn labels(&self) -> &[Option<String>] {
&self.labels
}
pub fn len(&self) -> usize {
self.len
}
}
impl SymbolSpaceBuilder {
pub fn new() -> Self {
Self {
symbols: 0,
unwritten_fns: Vec::new(),
fn_map: HashMap::new(),
data_map: HashMap::new(),
ro_data: Vec::new(),
fns: Vec::new(),
labels: Vec::new(),
}
}
pub fn with_entries(entries: &[FnID]) -> SymbolSpaceBuilder {
let mut s = Self::new();
for e in entries {
s.func(e);
}
s
}
pub fn pop_fn(&mut self) -> Option<(WritableSymbol, FnID)> {
self.unwritten_fns.pop()
}
@@ -94,7 +101,6 @@ impl SymbolSpaceBuilder {
data: Vec<u8>,
name: Option<String>,
) -> Symbol {
let data = data.into();
self.ro_data.push((*sym, data));
self.labels[sym.0 .0] = name;
*sym
@@ -116,11 +122,12 @@ impl SymbolSpaceBuilder {
WritableSymbol(Symbol(val))
}
pub fn len(&self) -> usize {
self.fns.len() + self.ro_data.len()
self.symbols
}
pub fn finish(self) -> Option<SymbolSpace> {
if self.unwritten_fns.is_empty() {
Some(SymbolSpace {
len: self.symbols,
fns: self.fns,
ro_data: self.ro_data,
labels: self.labels,

84
src/ir/upper/func.rs
View File

@@ -3,7 +3,7 @@ use std::{collections::HashMap, fmt::Write};
use super::{
arch::riscv64::RV64Instruction, inst::VarInst, DataID, FnID, IRUInstrInst, Type, VarID,
};
use crate::{common::FileSpan, compiler::arch::riscv::Reg, util::Padder};
use crate::{compiler::arch::riscv::Reg, util::Padder};
pub struct IRUFunction {
pub name: String,
@@ -54,50 +54,64 @@ pub enum IRUInstruction {
dest: VarInst,
fields: HashMap<String, VarInst>,
},
}
pub struct IRInstructions {
vec: Vec<IRUInstrInst>,
}
impl IRUFunction {
pub fn new(name: String, args: Vec<VarID>, ret: Type, instructions: IRInstructions) -> Self {
Self {
name,
ret,
args,
instructions: instructions.vec,
}
}
}
impl IRInstructions {
pub fn new() -> Self {
Self { vec: Vec::new() }
}
pub fn push(&mut self, i: IRUInstruction, span: FileSpan) {
self.vec.push(IRUInstrInst { i, span });
}
If {
cond: VarInst,
body: Vec<IRUInstrInst>,
},
Loop {
body: Vec<IRUInstrInst>,
},
Break,
}
impl std::fmt::Debug for IRUInstruction {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Mv { dest, src } => write!(f, "{dest:?} <- {src:?}"),
Self::Ref { dest, src } => write!(f, "{dest:?} <- &{src:?}"),
Self::LoadData { dest, src } => write!(f, "{dest:?} <- {src:?}"),
Self::LoadFn { dest, src } => write!(f, "{dest:?} <- {src:?}"),
Self::LoadSlice { dest, src } => write!(f, "{dest:?} <- &[{src:?}]"),
Self::Mv { dest, src } => write!(f, "{dest:?} <- {src:?}")?,
Self::Ref { dest, src } => write!(f, "{dest:?} <- &{src:?}")?,
Self::LoadData { dest, src } => write!(f, "{dest:?} <- {src:?}")?,
Self::LoadFn { dest, src } => write!(f, "{dest:?} <- {src:?}")?,
Self::LoadSlice { dest, src } => write!(f, "{dest:?} <- &[{src:?}]")?,
Self::Call {
dest,
f: func,
args,
} => write!(f, "{dest:?} <- {func:?}({args:?})"),
Self::AsmBlock { args, instructions } => write!(f, "asm {args:?} {instructions:#?}"),
Self::Ret { src } => f.debug_struct("Ret").field("src", src).finish(),
Self::Construct { dest, fields } => write!(f, "{dest:?} <- {fields:?}"),
Self::Access { dest, src, field } => write!(f, "{dest:?} <- {src:?}.{field}"),
} => write!(f, "{dest:?} <- {func:?}({args:?})")?,
Self::AsmBlock { args, instructions } => write!(f, "asm {args:?} {instructions:#?}")?,
Self::Ret { src } => f.debug_struct("Ret").field("src", src).finish()?,
Self::Construct { dest, fields } => write!(f, "{dest:?} <- {fields:?}")?,
Self::Access { dest, src, field } => write!(f, "{dest:?} <- {src:?}.{field}")?,
Self::If { cond, body } => {
write!(f, "if {cond:?}:")?;
if !body.is_empty() {
f.write_str("{\n ")?;
let mut padder = Padder::new(f);
for i in body {
// they don't expose wrap_buf :grief:
padder.write_str(&format!("{i:?};\n"))?;
}
f.write_char('}')?;
} else {
f.write_str("{}")?;
}
}
Self::Loop { body } => {
write!(f, "loop:")?;
if !body.is_empty() {
f.write_str("{\n ")?;
let mut padder = Padder::new(f);
for i in body {
// they don't expose wrap_buf :grief:
padder.write_str(&format!("{i:?};\n"))?;
}
f.write_char('}')?;
} else {
f.write_str("{}")?;
}
}
Self::Break => write!(f, "break")?,
}
Ok(())
}
}

28
src/ir/upper/program.rs
View File

@@ -1,7 +1,6 @@
use std::{
collections::HashMap,
fmt::Debug,
ops::{Deref, DerefMut},
};
use crate::common::FileSpan;
@@ -34,9 +33,11 @@ impl IRUProgram {
stack: vec![HashMap::new()],
}
}
pub fn push(&mut self) -> NamespaceGuard {
pub fn push(&mut self) {
self.stack.push(HashMap::new());
NamespaceGuard(self)
}
pub fn pop(&mut self) {
self.stack.pop();
}
pub fn get(&self, name: &str) -> Option<Idents> {
for map in self.stack.iter().rev() {
@@ -205,27 +206,6 @@ impl IRUProgram {
}
}
pub struct NamespaceGuard<'a>(&'a mut IRUProgram);
impl Drop for NamespaceGuard<'_> {
fn drop(&mut self) {
self.0.stack.pop();
}
}
impl Deref for NamespaceGuard<'_> {
type Target = IRUProgram;
fn deref(&self) -> &Self::Target {
self.0
}
}
impl DerefMut for NamespaceGuard<'_> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.0
}
}
#[derive(Debug, Clone, Copy)]
pub enum Ident {
Var(VarID),

232
src/ir/upper/validate.rs
View File

@@ -1,114 +1,140 @@
// TODO: move this into ir, not parser
use super::{IRUInstruction, IRUProgram, Type};
use super::{IRUInstrInst, IRUInstruction, IRUProgram, Type};
use crate::common::{CompilerMsg, CompilerOutput};
impl IRUProgram {
pub fn validate(&self) -> CompilerOutput {
let mut output = CompilerOutput::new();
for (f, fd) in self.fns.iter().flatten().zip(&self.fn_defs) {
for i in &f.instructions {
match &i.i {
IRUInstruction::Mv { dest, src } => {
let dest = self.get_var(dest.id);
let src = self.get_var(src.id);
output.check_assign(self, &src.ty, &dest.ty, i.span);
}
IRUInstruction::Ref { dest, src } => todo!(),
IRUInstruction::LoadData { dest, src } => {
let dest = self.get_var(dest.id);
let src = self.get_data(*src);
output.check_assign(self, &src.ty, &dest.ty, i.span);
}
IRUInstruction::LoadSlice { dest, src } => {
let dest = self.get_var(dest.id);
let src = self.get_data(*src);
let Type::Array(srcty, ..) = &src.ty else {
todo!()
};
output.check_assign(self, &Type::Slice(srcty.clone()), &dest.ty, i.span);
}
IRUInstruction::LoadFn { dest, src } => todo!(),
IRUInstruction::Call { dest, f, args } => {
let destty = &self.get_var(dest.id).ty;
let f = self.get_var(f.id);
let Type::Fn { args: argtys, ret } = &f.ty else {
todo!()
};
output.check_assign(self, ret, destty, dest.span);
if args.len() != argtys.len() {
output.err(CompilerMsg {
msg: "Wrong number of arguments to function".to_string(),
spans: vec![dest.span],
});
}
for (argv, argt) in args.iter().zip(argtys) {
let dest = self.get_var(argv.id);
output.check_assign(self, argt, &dest.ty, argv.span);
}
}
IRUInstruction::AsmBlock { instructions, args } => {
// TODO
}
IRUInstruction::Ret { src } => {
let srcty = &self.get_var(src.id).ty;
output.check_assign(self, srcty, &fd.ret, src.span);
}
IRUInstruction::Construct { dest, fields } => {
let dest_def = self.get_var(dest.id);
let tyid = match dest_def.ty {
Type::Concrete(id) => id,
_ => {
output.err(CompilerMsg {
msg: "uhh type is not struct".to_string(),
spans: vec![dest.span],
});
continue;
}
};
let def = self.get_struct(tyid);
for (name, field) in &def.fields {
if let Some(var) = fields.get(name) {
let ety = &self.get_var(var.id).ty;
output.check_assign(self, &field.ty, ety, var.span);
} else {
output.err(CompilerMsg {
msg: format!("field '{name}' missing from struct"),
spans: vec![dest.span],
});
}
}
for name in fields.keys() {
if !def.fields.contains_key(name) {
output.err(CompilerMsg {
msg: format!("field '{name}' not in struct"),
spans: vec![dest.span],
});
}
}
}
IRUInstruction::Access { dest, src, field } => {
let dest_def = self.get_var(dest.id);
let src_def = self.get_var(src.id);
let tyid = match src_def.ty {
Type::Concrete(id) => id,
_ => {
output.err(CompilerMsg {
msg: "uhh type is not struct".to_string(),
spans: vec![dest.span],
});
continue;
}
};
let def = self.get_struct(tyid);
let field = def.fields.get(field).expect(
"already validated during parse lowering... probably shouldn't be?",
);
output.check_assign(self, &field.ty, &dest_def.ty, i.span);
// TODO
}
}
}
self.validate_fn(&f.instructions, &fd.ret, &mut output, false);
}
output
}
pub fn validate_fn(
&self,
instructions: &[IRUInstrInst],
ret: &Type,
output: &mut CompilerOutput,
breakable: bool,
) {
for i in instructions {
match &i.i {
IRUInstruction::Mv { dest, src } => {
let dest = self.get_var(dest.id);
let src = self.get_var(src.id);
output.check_assign(self, &src.ty, &dest.ty, i.span);
}
IRUInstruction::Ref { dest, src } => todo!(),
IRUInstruction::LoadData { dest, src } => {
let dest = self.get_var(dest.id);
let src = self.get_data(*src);
output.check_assign(self, &src.ty, &dest.ty, i.span);
}
IRUInstruction::LoadSlice { dest, src } => {
let dest = self.get_var(dest.id);
let src = self.get_data(*src);
let Type::Array(srcty, ..) = &src.ty else {
todo!()
};
output.check_assign(self, &Type::Slice(srcty.clone()), &dest.ty, i.span);
}
IRUInstruction::LoadFn { dest, src } => todo!(),
IRUInstruction::Call { dest, f, args } => {
let destty = &self.get_var(dest.id).ty;
let f = self.get_var(f.id);
let Type::Fn { args: argtys, ret } = &f.ty else {
todo!()
};
output.check_assign(self, ret, destty, dest.span);
if args.len() != argtys.len() {
output.err(CompilerMsg {
msg: "Wrong number of arguments to function".to_string(),
spans: vec![dest.span],
});
}
for (argv, argt) in args.iter().zip(argtys) {
let dest = self.get_var(argv.id);
output.check_assign(self, argt, &dest.ty, argv.span);
}
}
IRUInstruction::AsmBlock { instructions, args } => {
// TODO
}
IRUInstruction::Ret { src } => {
let srcty = &self.get_var(src.id).ty;
output.check_assign(self, srcty, ret, src.span);
}
IRUInstruction::Construct { dest, fields } => {
let dest_def = self.get_var(dest.id);
let tyid = match dest_def.ty {
Type::Concrete(id) => id,
_ => {
output.err(CompilerMsg {
msg: "uhh type is not struct".to_string(),
spans: vec![dest.span],
});
continue;
}
};
let def = self.get_struct(tyid);
for (name, field) in &def.fields {
if let Some(var) = fields.get(name) {
let ety = &self.get_var(var.id).ty;
output.check_assign(self, &field.ty, ety, var.span);
} else {
output.err(CompilerMsg {
msg: format!("field '{name}' missing from struct"),
spans: vec![dest.span],
});
}
}
for name in fields.keys() {
if !def.fields.contains_key(name) {
output.err(CompilerMsg {
msg: format!("field '{name}' not in struct"),
spans: vec![dest.span],
});
}
}
}
IRUInstruction::Access { dest, src, field } => {
let dest_def = self.get_var(dest.id);
let src_def = self.get_var(src.id);
let tyid = match src_def.ty {
Type::Concrete(id) => id,
_ => {
output.err(CompilerMsg {
msg: "uhh type is not struct".to_string(),
spans: vec![dest.span],
});
continue;
}
};
let def = self.get_struct(tyid);
let field = def.fields.get(field).expect(
"already validated during parse lowering... probably shouldn't be?",
);
output.check_assign(self, &field.ty, &dest_def.ty, i.span);
}
IRUInstruction::If { cond, body } => {
let cond = self.get_var(cond.id);
output.check_assign(self, &cond.ty, &Type::Bits(64), i.span);
self.validate_fn(body, ret, output, breakable);
}
IRUInstruction::Loop { body } => {
self.validate_fn(body, ret, output, true);
}
IRUInstruction::Break => {
if !breakable {
output.err(CompilerMsg {
msg: "Can't break here (outside of loop)".to_string(),
spans: vec![i.span],
});
}
// TODO
}
}
}
}
}