diff --git a/reid-llvm-lib/src/builder.rs b/reid-llvm-lib/src/builder.rs index 63362b5..c56e450 100644 --- a/reid-llvm-lib/src/builder.rs +++ b/reid-llvm-lib/src/builder.rs @@ -1,4 +1,4 @@ -use std::{cell::RefCell, marker::PhantomData, rc::Rc}; +use std::{cell::RefCell, rc::Rc}; use crate::{ BlockData, ConstValue, FunctionData, InstructionData, InstructionKind, ModuleData, @@ -140,6 +140,7 @@ impl Builder { } } + #[allow(dead_code)] pub(crate) unsafe fn module_data(&self, value: &ModuleValue) -> ModuleData { unsafe { self.modules.borrow().get_unchecked(value.0).data.clone() } } @@ -156,6 +157,7 @@ impl Builder { } } + #[allow(dead_code)] pub(crate) unsafe fn block_data(&self, value: &BlockValue) -> BlockData { unsafe { self.modules @@ -235,7 +237,6 @@ impl Builder { impl InstructionValue { pub fn get_type(&self, builder: &Builder) -> Result { use InstructionKind::*; - use Type::*; unsafe { match &builder.instr_data(self).kind { Param(nth) => builder @@ -247,7 +248,7 @@ impl InstructionValue { Constant(c) => Ok(c.get_type()), Add(lhs, rhs) => match_types(lhs, rhs, &builder), Sub(lhs, rhs) => match_types(lhs, rhs, &builder), - ICmp(pred, lhs, rhs) => Ok(Type::Bool), + ICmp(_, _, _) => Ok(Type::Bool), FunctionCall(function_value, _) => Ok(builder.function_data(function_value).ret), Phi(values) => values.first().ok_or(()).and_then(|v| v.get_type(&builder)), } diff --git a/reid-llvm-lib/src/compile.rs b/reid-llvm-lib/src/compile.rs index 39430a0..be78af0 100644 --- a/reid-llvm-lib/src/compile.rs +++ b/reid-llvm-lib/src/compile.rs @@ -1,4 +1,4 @@ -use std::{collections::HashMap, ffi::CString, hash::Hash, process::Termination, ptr::null_mut}; +use std::{collections::HashMap, ffi::CString, ptr::null_mut}; use llvm_sys::{ LLVMIntPredicate, @@ -18,7 +18,7 @@ use llvm_sys::{ use crate::util::{ErrorMessageHolder, from_cstring, into_cstring}; use super::{ - ConstValue, Context, Function, IntPredicate, Module, TerminatorKind, Type, + ConstValue, Context, IntPredicate, TerminatorKind, Type, builder::{ BlockHolder, BlockValue, Builder, FunctionHolder, FunctionValue, InstructionHolder, InstructionValue, ModuleHolder, @@ -54,6 +54,7 @@ pub struct LLVMModule<'a> { builder: &'a Builder, context_ref: LLVMContextRef, builder_ref: LLVMBuilderRef, + #[allow(dead_code)] module_ref: LLVMModuleRef, functions: HashMap, blocks: HashMap, @@ -67,7 +68,7 @@ pub struct LLVMFunction { } pub struct LLVMValue { - ty: Type, + _ty: Type, value_ref: LLVMValueRef, } @@ -244,9 +245,9 @@ impl InstructionHolder { &self, module: &LLVMModule, function: &LLVMFunction, - block: LLVMBasicBlockRef, + _block: LLVMBasicBlockRef, ) -> LLVMValue { - let ty = self.value.get_type(module.builder).unwrap(); + let _ty = self.value.get_type(module.builder).unwrap(); let val = unsafe { use super::InstructionKind::*; match &self.data.kind { @@ -267,7 +268,7 @@ impl InstructionHolder { let rhs_val = module.values.get(&rhs).unwrap().value_ref; LLVMBuildICmp( module.builder_ref, - pred.as_llvm(ty.signed()), + pred.as_llvm(_ty.signed()), lhs_val, rhs_val, c"icmp".as_ptr(), @@ -298,7 +299,7 @@ impl InstructionHolder { } let phi = LLVMBuildPhi( module.builder_ref, - ty.as_llvm(module.context_ref), + _ty.as_llvm(module.context_ref), c"phi".as_ptr(), ); LLVMAddIncoming( @@ -311,7 +312,10 @@ impl InstructionHolder { } } }; - LLVMValue { ty, value_ref: val } + LLVMValue { + _ty, + value_ref: val, + } } } @@ -319,10 +323,10 @@ impl TerminatorKind { fn compile( &self, module: &LLVMModule, - function: &LLVMFunction, - block: LLVMBasicBlockRef, + _function: &LLVMFunction, + _block: LLVMBasicBlockRef, ) -> LLVMValue { - let ty = self.get_type(module.builder).unwrap(); + let _ty = self.get_type(module.builder).unwrap(); let val = unsafe { match self { TerminatorKind::Ret(val) => { @@ -341,7 +345,10 @@ impl TerminatorKind { } } }; - LLVMValue { ty, value_ref: val } + LLVMValue { + _ty, + value_ref: val, + } } } diff --git a/reid-llvm-lib/src/lib.rs b/reid-llvm-lib/src/lib.rs index a2a3cf6..aefbe88 100644 --- a/reid-llvm-lib/src/lib.rs +++ b/reid-llvm-lib/src/lib.rs @@ -178,57 +178,3 @@ pub enum TerminatorKind { Branch(BlockValue), CondBr(InstructionValue, BlockValue, BlockValue), } - -fn test() { - use ConstValue::*; - use InstructionKind::*; - - let context = Context::new(); - - let mut module = context.module("test"); - - let mut main = module.function("main", Type::I32, Vec::new()); - let mut m_entry = main.block("entry"); - - let mut fibonacci = module.function("fibonacci", Type::I32, vec![Type::I32]); - - let arg = m_entry.build(Constant(I32(5))).unwrap(); - m_entry - .build(FunctionCall(fibonacci.value, vec![arg])) - .unwrap(); - - let mut f_entry = fibonacci.block("entry"); - - let num_3 = f_entry.build(Constant(I32(3))).unwrap(); - let param_n = f_entry.build(Param(0)).unwrap(); - let cond = f_entry - .build(ICmp(IntPredicate::LessThan, param_n, num_3)) - .unwrap(); - - let mut then_b = fibonacci.block("then"); - let mut else_b = fibonacci.block("else"); - - f_entry - .terminate(TerminatorKind::CondBr(cond, then_b.value, else_b.value)) - .unwrap(); - - let ret_const = then_b.build(Constant(I32(1))).unwrap(); - then_b.terminate(TerminatorKind::Ret(ret_const)).unwrap(); - - let const_1 = else_b.build(Constant(I32(1))).unwrap(); - let const_2 = else_b.build(Constant(I32(2))).unwrap(); - let param_1 = else_b.build(Sub(param_n, const_1)).unwrap(); - let param_2 = else_b.build(Sub(param_n, const_2)).unwrap(); - let call_1 = else_b - .build(FunctionCall(fibonacci.value, vec![param_1])) - .unwrap(); - let call_2 = else_b - .build(FunctionCall(fibonacci.value, vec![param_2])) - .unwrap(); - - let add = else_b.build(Add(call_1, call_2)).unwrap(); - - else_b.terminate(TerminatorKind::Ret(add)).unwrap(); - - dbg!(context); -} diff --git a/reid/src/ast/mod.rs b/reid/src/ast/mod.rs index 01d2cf0..7a8265e 100644 --- a/reid/src/ast/mod.rs +++ b/reid/src/ast/mod.rs @@ -53,10 +53,19 @@ impl BinaryOperator { } #[derive(Debug, Clone)] -pub struct FunctionCallExpression(pub String, pub Vec, pub TokenRange); +pub struct FunctionCallExpression( + pub String, + pub Vec, + #[allow(dead_code)] pub TokenRange, +); #[derive(Debug, Clone)] -pub struct IfExpression(pub Expression, pub Block, pub Option, pub TokenRange); +pub struct IfExpression( + pub Expression, + pub Block, + pub Option, + #[allow(dead_code)] pub TokenRange, +); #[derive(Debug, Clone)] pub struct LetStatement(pub String, pub Option, pub Expression, pub TokenRange); @@ -72,6 +81,7 @@ pub struct FunctionSignature { pub name: String, pub args: Vec<(String, Type)>, pub return_type: Option, + #[allow(dead_code)] pub range: TokenRange, } @@ -91,7 +101,7 @@ pub struct Block( #[derive(Debug, Clone)] pub enum BlockLevelStatement { Let(LetStatement), - Import(ImportStatement), + Import { _i: ImportStatement }, Expression(Expression), Return(ReturnType, Expression), } diff --git a/reid/src/ast/parse.rs b/reid/src/ast/parse.rs index f679261..9c16235 100644 --- a/reid/src/ast/parse.rs +++ b/reid/src/ast/parse.rs @@ -308,7 +308,9 @@ impl Parse for BlockLevelStatement { use BlockLevelStatement as Stmt; Ok(match stream.peek() { Some(Token::LetKeyword) => Stmt::Let(stream.parse()?), - Some(Token::ImportKeyword) => Stmt::Import(stream.parse()?), + Some(Token::ImportKeyword) => Stmt::Import { + _i: stream.parse()?, + }, Some(Token::ReturnKeyword) => { stream.next(); let exp = stream.parse()?; diff --git a/reid/src/ast/process.rs b/reid/src/ast/process.rs index c7185b2..faafac1 100644 --- a/reid/src/ast/process.rs +++ b/reid/src/ast/process.rs @@ -1,45 +1,8 @@ -use std::collections::HashMap; - use crate::{ - ast::{self, TypeKind}, + ast::{self}, mir::{self, StmtKind, VariableReference}, }; -#[derive(Clone)] -pub enum InferredType { - FromVariable(String), - FunctionReturn(String), - Static(mir::TypeKind), - OneOf(Vec), - Void, - Unknown, -} - -impl InferredType { - fn collapse(&self) -> mir::TypeKind { - match self { - InferredType::FromVariable(_) => mir::TypeKind::Vague(mir::VagueType::Unknown), - InferredType::FunctionReturn(_) => mir::TypeKind::Vague(mir::VagueType::Unknown), - InferredType::Static(type_kind) => type_kind.clone(), - InferredType::OneOf(inferred_types) => { - let list: Vec = - inferred_types.iter().map(|t| t.collapse()).collect(); - if let Some(first) = list.first() { - if list.iter().all(|i| i == first) { - first.clone().into() - } else { - mir::TypeKind::Vague(mir::VagueType::Unknown) - } - } else { - mir::TypeKind::Void - } - } - InferredType::Void => mir::TypeKind::Void, - InferredType::Unknown => mir::TypeKind::Vague(mir::VagueType::Unknown), - } - } -} - impl ast::Module { pub fn process(&self) -> mir::Module { let mut imports = Vec::new(); @@ -103,7 +66,7 @@ impl ast::Block { ), s_let.3, ), - ast::BlockLevelStatement::Import(_) => todo!(), + ast::BlockLevelStatement::Import { _i } => todo!(), ast::BlockLevelStatement::Expression(e) => (StmtKind::Expression(e.process()), e.1), ast::BlockLevelStatement::Return(_, e) => (StmtKind::Expression(e.process()), e.1), }; diff --git a/reid/src/codegen.rs b/reid/src/codegen.rs index 58fec08..c5a0bd0 100644 --- a/reid/src/codegen.rs +++ b/reid/src/codegen.rs @@ -1,9 +1,8 @@ -use std::{collections::HashMap, mem, ops::Deref}; +use std::{collections::HashMap, mem}; use reid_lib::{ - builder::{FunctionValue, InstructionValue}, - Block, ConstValue, Context, Function, InstructionKind, IntPredicate, Module, TerminatorKind, - Type, + builder::InstructionValue, Block, ConstValue, Context, Function, InstructionKind, IntPredicate, + Module, TerminatorKind, Type, }; use crate::mir::{self, types::ReturnType, TypeKind, VariableReference}; @@ -40,7 +39,7 @@ impl mir::Module { let mut entry = function.block("entry"); let mut stack_values = HashMap::new(); - for (i, (p_name, p_type)) in mir_function.parameters.iter().enumerate() { + for (i, (p_name, _)) in mir_function.parameters.iter().enumerate() { stack_values.insert( p_name.clone(), entry.build(InstructionKind::Param(i)).unwrap(), diff --git a/reid/src/mir/typecheck.rs b/reid/src/mir/typecheck.rs index 5cd606a..3ecbd03 100644 --- a/reid/src/mir/typecheck.rs +++ b/reid/src/mir/typecheck.rs @@ -1,7 +1,7 @@ use std::{collections::HashMap, convert::Infallible, iter}; /// This module contains code relevant to doing a type checking pass on the MIR. -use crate::{ast::Type, mir::*, util::try_all}; +use crate::{mir::*, util::try_all}; use TypeKind::*; use VagueType::*; diff --git a/reid/src/token_stream.rs b/reid/src/token_stream.rs index d35d6f9..a529476 100644 --- a/reid/src/token_stream.rs +++ b/reid/src/token_stream.rs @@ -76,6 +76,7 @@ impl<'a, 'b> TokenStream<'a, 'b> { /// Parse the next item with Parse-trait, also mapping it with the given /// function. The token-stream is only consumed, if the inner function /// retuns an Ok. + #[allow(dead_code)] pub fn parse_map(&mut self, inner: F) -> Result where F: Fn(T) -> Result,