examples/for_loops.reid

@@ -1,11 +0,0 @@
-import std::print;
-import std::from_str;
-
-fn main() {
-    for i in 0..1 {
-        print(from_str("Hello!"));
-    }
-    for i in 0..1 {
-        print(from_str("Hello!"));
-    }
-}

examples/loop_hard.reid

@@ -1,27 +0,0 @@
-import std::print;
-import std::new_string;
-import std::add_num_to_str;
-import std::add_char;
-
-fn main() -> u8 {
-    for i in 0..5 {
-        for j in 0..5 {
-            for k in 0..5 {
-                let mut test = new_string();
-                add_num_to_str(&mut test, i);
-                add_char(&mut test, ',');
-                add_num_to_str(&mut test, j);
-                add_char(&mut test, ',');
-                add_num_to_str(&mut test, k);
-                print(test);
-            }
-        }
-    }
-    for i in 0..1000 {
-        for j in 0..1000 {
-            for k in 0..1000 {
-            }
-        }
-    }
-    return 0;
-}

examples/ptr_hard.reid

@@ -1,9 +0,0 @@
-fn main() -> u8 {
-    let mut a = 5;
-    inner(&mut a);
-    return 0;
-}
-
-fn inner(a: &mut i32) {
-    *a = *a + 1;
-}

reid-llvm-lib/src/compile.rs

@@ -676,7 +676,7 @@ impl FunctionHolder {
 
                 let block_ref = LLVMCreateBasicBlockInContext(
                     module.context_ref,
-                    into_cstring(&block.data.name).as_ptr(),
+                    into_cstring(&self.data.name).as_ptr(),
                 );
                 LLVMAppendExistingBasicBlock(own_function.value_ref, block_ref);
                 module.blocks.insert(block.value, block_ref);

reid/src/allocator.rs

@@ -1,183 +0,0 @@
-use std::collections::HashMap;
-
-use reid_lib::{
-    builder::{InstructionValue, TypeValue},
-    Block,
-};
-
-use crate::mir::{
-    self, CustomTypeKey, FunctionCall, FunctionDefinition, IfExpression, SourceModuleId,
-    TypeDefinition, TypeKind, WhileStatement,
-};
-
-#[derive(Debug)]
-pub struct Allocator {
-    allocations: Vec<Allocation>,
-}
-
-pub struct AllocatorScope<'ctx, 'a> {
-    pub(super) block: &'a mut Block<'ctx>,
-    pub(super) module_id: SourceModuleId,
-    pub(super) types: &'a HashMap<TypeValue, TypeDefinition>,
-    pub(super) type_values: &'a HashMap<CustomTypeKey, TypeValue>,
-}
-
-impl Allocator {
-    pub fn from(func: &FunctionDefinition, scope: &mut AllocatorScope) -> Allocator {
-        func.allocate(scope)
-    }
-
-    pub fn allocate(&mut self, name: &String, ty: &TypeKind) -> Option<InstructionValue> {
-        let mut allocs = self.allocations.iter().cloned().enumerate();
-        let val = allocs.find(|a| a.1 .0 == *name && a.1 .1 == *ty);
-        if let Some((i, _)) = val {
-            self.allocations.remove(i);
-        }
-        val.map(|v| v.1 .2)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Allocation(String, TypeKind, InstructionValue);
-
-impl mir::FunctionDefinition {
-    fn allocate<'ctx, 'a>(&self, scope: &mut AllocatorScope<'ctx, 'a>) -> Allocator {
-        let mut allocated = Vec::new();
-        match &self.kind {
-            crate::mir::FunctionDefinitionKind::Local(block, _) => {
-                for param in &self.parameters {
-                    let allocation = scope
-                        .block
-                        .build_named(
-                            param.0.clone(),
-                            reid_lib::Instr::Alloca(
-                                param.1.get_type(scope.type_values, scope.types),
-                            ),
-                        )
-                        .unwrap();
-                    allocated.push(Allocation(param.0.clone(), param.1.clone(), allocation));
-                }
-                allocated.extend(block.allocate(scope));
-            }
-            crate::mir::FunctionDefinitionKind::Extern(_) => {}
-        }
-
-        Allocator {
-            allocations: allocated,
-        }
-    }
-}
-
-impl mir::Block {
-    fn allocate<'ctx, 'a>(&self, scope: &mut AllocatorScope<'ctx, 'a>) -> Vec<Allocation> {
-        let mut allocated = Vec::new();
-
-        for statement in &self.statements {
-            allocated.extend(statement.allocate(scope));
-        }
-
-        if let Some((_, ret_expr)) = &self.return_expression {
-            allocated.extend(ret_expr.allocate(scope));
-        }
-
-        allocated
-    }
-}
-
-impl mir::Statement {
-    fn allocate<'ctx, 'a>(&self, scope: &mut AllocatorScope<'ctx, 'a>) -> Vec<Allocation> {
-        let mut allocated = Vec::new();
-
-        match &self.0 {
-            crate::mir::StmtKind::Let(named_variable_ref, _, expression) => {
-                allocated.extend(expression.allocate(scope));
-                let allocation = scope
-                    .block
-                    .build_named(
-                        named_variable_ref.1.clone(),
-                        reid_lib::Instr::Alloca(
-                            named_variable_ref
-                                .0
-                                .get_type(scope.type_values, scope.types),
-                        ),
-                    )
-                    .unwrap();
-                allocated.push(Allocation(
-                    named_variable_ref.1.clone(),
-                    named_variable_ref.0.clone(),
-                    allocation,
-                ));
-            }
-            crate::mir::StmtKind::Set(lhs, rhs) => {
-                allocated.extend(lhs.allocate(scope));
-                allocated.extend(rhs.allocate(scope));
-            }
-            crate::mir::StmtKind::Import(_) => {}
-            crate::mir::StmtKind::Expression(expression) => {
-                allocated.extend(expression.allocate(scope));
-            }
-            crate::mir::StmtKind::While(WhileStatement {
-                condition, block, ..
-            }) => {
-                allocated.extend(condition.allocate(scope));
-                allocated.extend(block.allocate(scope));
-            }
-        }
-
-        allocated
-    }
-}
-
-impl mir::Expression {
-    fn allocate<'ctx, 'a>(&self, scope: &mut AllocatorScope<'ctx, 'a>) -> Vec<Allocation> {
-        let mut allocated = Vec::new();
-
-        match &self.0 {
-            crate::mir::ExprKind::Variable(_) => {}
-            crate::mir::ExprKind::Indexed(expr, _, idx) => {
-                allocated.extend(expr.allocate(scope));
-                allocated.extend(idx.allocate(scope));
-            }
-            crate::mir::ExprKind::Accessed(expression, _, _) => {
-                allocated.extend(expression.allocate(scope));
-            }
-            crate::mir::ExprKind::Array(expressions) => {
-                for expression in expressions {
-                    allocated.extend(expression.allocate(scope));
-                }
-            }
-            crate::mir::ExprKind::Struct(_, items) => {
-                for (_, expression) in items {
-                    allocated.extend(expression.allocate(scope));
-                }
-            }
-            crate::mir::ExprKind::Literal(_) => {}
-            crate::mir::ExprKind::BinOp(_, lhs, rhs) => {
-                allocated.extend(lhs.allocate(scope));
-                allocated.extend(rhs.allocate(scope));
-            }
-            crate::mir::ExprKind::FunctionCall(FunctionCall { parameters, .. }) => {
-                for param in parameters {
-                    allocated.extend(param.allocate(scope));
-                }
-            }
-            crate::mir::ExprKind::If(IfExpression(cond, then_ex, else_ex)) => {
-                allocated.extend(cond.allocate(scope));
-                allocated.extend(then_ex.allocate(scope));
-                if let Some(else_ex) = else_ex.as_ref() {
-                    allocated.extend(else_ex.allocate(scope));
-                }
-            }
-            crate::mir::ExprKind::Block(block) => {
-                allocated.extend(block.allocate(scope));
-            }
-            crate::mir::ExprKind::Borrow(_, _) => {}
-            crate::mir::ExprKind::Deref(_) => {}
-            crate::mir::ExprKind::CastTo(expression, _) => {
-                allocated.extend(expression.allocate(scope));
-            }
-        }
-
-        allocated
-    }
-}

reid/src/ast/process.rs

@@ -158,6 +158,7 @@ impl ast::Block {
                         StmtKind::Let(counter_var.clone(), true, start.process(module_id)),
                         counter_range.as_meta(module_id),
                     );
+                    mir_statements.push(let_statement);
 
                     let set_new = mir::Statement(
                         StmtKind::Set(
@@ -186,7 +187,7 @@ impl ast::Block {
                     );
                     let mut block = block.into_mir(module_id);
                     block.statements.push(set_new);
-                    let while_statement = mir::Statement(
+                    (
                         StmtKind::While(WhileStatement {
                             condition: mir::Expression(
                                 mir::ExprKind::BinOp(
@@ -202,18 +203,8 @@ impl ast::Block {
                             block,
                             meta: self.2.as_meta(module_id),
                         }),
-                        self.2.as_meta(module_id),
+                        self.2,
-                    );
+                    )
-
-                    let inner_scope = StmtKind::Expression(mir::Expression(
-                        mir::ExprKind::Block(mir::Block {
-                            statements: vec![let_statement, while_statement],
-                            return_expression: None,
-                            meta: counter_range.as_meta(module_id) + end.1.as_meta(module_id),
-                        }),
-                        counter_range.as_meta(module_id) + end.1.as_meta(module_id),
-                    ));
-                    (inner_scope, self.2)
                 }
                 ast::BlockLevelStatement::WhileLoop(expression, block) => (
                     StmtKind::While(WhileStatement {

reid/src/codegen.rs

@@ -1,4 +1,4 @@
-use std::{cell::RefCell, collections::HashMap, mem, rc::Rc};
+use std::{collections::HashMap, mem};
 
 use reid_lib::{
     builder::{InstructionValue, TypeValue},
@@ -15,7 +15,6 @@ use reid_lib::{
 };
 
 use crate::{
-    allocator::{Allocator, AllocatorScope},
     lexer::{FullToken, Position},
     mir::{
         self, implement::TypeCategory, CustomTypeKey, Metadata, NamedVariableRef, SourceModuleId,
@@ -77,15 +76,14 @@ pub struct Scope<'ctx, 'scope> {
     modules: &'scope HashMap<SourceModuleId, ModuleCodegen<'ctx>>,
     tokens: &'ctx Vec<FullToken>,
     module: &'ctx Module<'ctx>,
-    pub(super) module_id: SourceModuleId,
+    module_id: SourceModuleId,
     function: &'ctx StackFunction<'ctx>,
-    pub(super) block: Block<'ctx>,
+    block: Block<'ctx>,
-    pub(super) types: &'scope HashMap<TypeValue, TypeDefinition>,
+    types: &'scope HashMap<TypeValue, TypeDefinition>,
-    pub(super) type_values: &'scope HashMap<CustomTypeKey, TypeValue>,
+    type_values: &'scope HashMap<CustomTypeKey, TypeValue>,
     functions: &'scope HashMap<String, StackFunction<'ctx>>,
     stack_values: HashMap<String, StackValue>,
     debug: Option<Debug<'ctx>>,
-    allocator: Rc<RefCell<Allocator>>,
 }
 
 #[derive(Debug, Clone)]
@@ -163,7 +161,6 @@ impl<'ctx, 'a> Scope<'ctx, 'a> {
             type_values: self.type_values,
             stack_values: self.stack_values.clone(),
             debug: self.debug.clone(),
-            allocator: self.allocator.clone(),
         }
     }
 
@@ -178,10 +175,6 @@ impl<'ctx, 'a> Scope<'ctx, 'a> {
     fn get_typedef(&self, key: &CustomTypeKey) -> Option<&TypeDefinition> {
         self.type_values.get(key).and_then(|v| self.types.get(v))
     }
-
-    fn allocate(&self, name: &String, ty: &TypeKind) -> Option<InstructionValue> {
-        self.allocator.borrow_mut().allocate(name, ty)
-    }
 }
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
@@ -328,15 +321,6 @@ impl mir::Module {
             match &mir_function.kind {
                 mir::FunctionDefinitionKind::Local(block, _) => {
                     let mut entry = function.ir.block("entry");
-                    let mut allocator = Allocator::from(
-                        mir_function,
-                        &mut AllocatorScope {
-                            block: &mut entry,
-                            module_id: self.module_id,
-                            types: &types,
-                            type_values: &type_values,
-                        },
-                    );
 
                     // Insert debug information
                     let debug_scope = if let Some(location) =
@@ -388,9 +372,12 @@ impl mir::Module {
                         let param = entry
                             .build_named(format!("{}.get", arg_name), Instr::Param(i))
                             .unwrap();
-
+                        let alloca = entry
-                        let alloca = allocator.allocate(&p_name, &p_ty).unwrap();
+                            .build_named(
-
+                                &arg_name,
+                                Instr::Alloca(p_ty.get_type(&type_values, &types)),
+                            )
+                            .unwrap();
                         entry
                             .build_named(format!("{}.store", arg_name), Instr::Store(alloca, param))
                             .unwrap();
@@ -448,7 +435,6 @@ impl mir::Module {
                                 types: &debug_types,
                             })
                         }),
-                        allocator: Rc::new(RefCell::new(allocator)),
                     };
 
                     let state = State::default();
@@ -528,11 +514,15 @@ impl mir::Statement {
                 let value = expression.codegen(scope, &state)?.unwrap();
 
                 let alloca = scope
-                    .allocate(name, &value.1)
+                    .block
+                    .build_named(
+                        name,
+                        Instr::Alloca(value.1.get_type(scope.type_values, scope.types)),
+                    )
                     .unwrap()
                     .maybe_location(&mut scope.block, location);
 
-                let store = scope
+                scope
                     .block
                     .build_named(
                         format!("{}.store", name),
@@ -561,7 +551,7 @@ impl mir::Statement {
                             flags: DwarfFlags,
                         }),
                     );
-                    store.add_record(
+                    alloca.add_record(
                         &mut scope.block,
                         InstructionDebugRecordData {
                             variable: var,
@@ -612,9 +602,9 @@ impl mir::Statement {
             mir::StmtKind::While(WhileStatement {
                 condition, block, ..
             }) => {
-                let condition_block = scope.function.ir.block("while.cond");
+                let condition_block = scope.function.ir.block("condition_block");
-                let condition_true_block = scope.function.ir.block("while.body");
+                let condition_true_block = scope.function.ir.block("condition_true");
-                let condition_failed_block = scope.function.ir.block("while.end");
+                let condition_failed_block = scope.function.ir.block("condition_failed");
 
                 scope
                     .block
@@ -1189,7 +1179,7 @@ impl mir::Expression {
 
                 Some({
                     if state.should_load {
-                        if let TypeKind::Borrow(inner, _) = *ptr_inner.clone() {
+                        if let TypeKind::CodegenPtr(inner) = *ptr_inner.clone() {
                             StackValue(
                                 v.0.derive(
                                     scope
@@ -1438,7 +1428,7 @@ impl mir::Literal {
 }
 
 impl TypeKind {
-    pub(super) fn get_type(
+    fn get_type(
         &self,
         type_vals: &HashMap<CustomTypeKey, TypeValue>,
         typedefs: &HashMap<TypeValue, TypeDefinition>,

reid/src/lib.rs

@@ -52,7 +52,6 @@ use reid_lib::{compile::CompileOutput, Context};
 
 use crate::{ast::TopLevelStatement, lexer::Token, token_stream::TokenStream};
 
-mod allocator;
 mod ast;
 mod codegen;
 pub mod error_raporting;

reid/tests/e2e.rs

@@ -124,11 +124,3 @@ fn struct_compiles_well() {
 fn loops_compiles_well() {
     test(include_str!("../../examples/loops.reid"), "test", 10);
 }
-#[test]
-fn ptr_hard_compiles_well() {
-    test(include_str!("../../examples/ptr_hard.reid"), "test", 0);
-}
-#[test]
-fn loop_hard_compiles_well() {
-    test(include_str!("../../examples/loop_hard.reid"), "test", 0);
-}