diff --git a/reid/src/ast/mod.rs b/reid/src/ast/mod.rs
index b60ce9a..8a307f0 100644
--- a/reid/src/ast/mod.rs
+++ b/reid/src/ast/mod.rs
@@ -196,9 +196,9 @@ pub struct FunctionSignature {
 
 #[derive(Debug, Clone)]
 pub enum SelfKind {
-    Owned(TypeKind),
-    Borrow(TypeKind),
-    MutBorrow(TypeKind),
+    Owned(Type),
+    Borrow(Type),
+    MutBorrow(Type),
     None,
 }
 
diff --git a/reid/src/ast/parse.rs b/reid/src/ast/parse.rs
index a4ba0d7..b26460b 100644
--- a/reid/src/ast/parse.rs
+++ b/reid/src/ast/parse.rs
@@ -696,9 +696,18 @@ impl Parse for SelfParam {
         };
         if name == "self" {
             match kind {
-                SelfParamKind::BorrowMut => Ok(SelfParam(SelfKind::MutBorrow(TypeKind::Unknown))),
-                SelfParamKind::Borrow => Ok(SelfParam(SelfKind::Borrow(TypeKind::Unknown))),
-                SelfParamKind::Owned => Ok(SelfParam(SelfKind::Owned(TypeKind::Unknown))),
+                SelfParamKind::BorrowMut => Ok(SelfParam(SelfKind::MutBorrow(Type(
+                    TypeKind::Unknown,
+                    stream.get_range_prev().unwrap(),
+                )))),
+                SelfParamKind::Borrow => Ok(SelfParam(SelfKind::Borrow(Type(
+                    TypeKind::Unknown,
+                    stream.get_range_prev().unwrap(),
+                )))),
+                SelfParamKind::Owned => Ok(SelfParam(SelfKind::Owned(Type(
+                    TypeKind::Unknown,
+                    stream.get_range_prev().unwrap(),
+                )))),
             }
         } else {
             Err(stream.expected_err("self parameter")?)
@@ -1091,9 +1100,9 @@ impl Parse for AssociatedFunctionBlock {
                 Some(Token::FnKeyword) | Some(Token::PubKeyword) => {
                     let mut fun: FunctionDefinition = stream.parse()?;
                     fun.0.self_kind = match fun.0.self_kind {
-                        SelfKind::Owned(_) => SelfKind::Owned(ty.0.clone()),
-                        SelfKind::Borrow(_) => SelfKind::Borrow(ty.0.clone()),
-                        SelfKind::MutBorrow(_) => SelfKind::MutBorrow(ty.0.clone()),
+                        SelfKind::Owned(_) => SelfKind::Owned(ty.clone()),
+                        SelfKind::Borrow(_) => SelfKind::Borrow(ty.clone()),
+                        SelfKind::MutBorrow(_) => SelfKind::MutBorrow(ty.clone()),
                         SelfKind::None => SelfKind::None,
                     };
                     functions.push(fun);
diff --git a/reid/src/ast/process.rs b/reid/src/ast/process.rs
index e527bce..4b1caf8 100644
--- a/reid/src/ast/process.rs
+++ b/reid/src/ast/process.rs
@@ -3,8 +3,8 @@ use std::path::PathBuf;
 use crate::{
     ast::{self},
     mir::{
-        self, CustomTypeKey, ModuleMap, NamedVariableRef, ReturnKind, SourceModuleId, StmtKind, StructField,
-        StructType, WhileStatement,
+        self, CustomTypeKey, FunctionParam, ModuleMap, NamedVariableRef, ReturnKind, SourceModuleId, StmtKind,
+        StructField, StructType, WhileStatement,
     },
 };
 
@@ -48,7 +48,11 @@ impl ast::Module {
                             .params
                             .iter()
                             .cloned()
-                            .map(|p| (p.0, p.1 .0.into_mir(module_id)))
+                            .map(|p| mir::FunctionParam {
+                                name: p.0,
+                                ty: p.1 .0.into_mir(module_id),
+                                meta: p.1 .1.as_meta(module_id),
+                            })
                             .collect(),
                         kind: mir::FunctionDefinitionKind::Extern(false),
                     };
@@ -88,9 +92,17 @@ impl ast::Module {
                     signature_range,
                 }) => {
                     binops.push(mir::BinopDefinition {
-                        lhs: (lhs.0.clone(), lhs.1 .0.into_mir(module_id)),
+                        lhs: mir::FunctionParam {
+                            name: lhs.0.clone(),
+                            ty: lhs.1 .0.into_mir(module_id),
+                            meta: lhs.1 .1.as_meta(module_id),
+                        },
                         op: op.mir(),
-                        rhs: (rhs.0.clone(), rhs.1 .0.into_mir(module_id)),
+                        rhs: mir::FunctionParam {
+                            name: rhs.0.clone(),
+                            ty: rhs.1 .0.into_mir(module_id),
+                            meta: rhs.1 .1.as_meta(module_id),
+                        },
                         return_type: return_ty.0.into_mir(module_id),
                         fn_kind: mir::FunctionDefinitionKind::Local(
                             block.into_mir(module_id),
@@ -129,25 +141,29 @@ impl ast::FunctionDefinition {
 
         let mut params = Vec::new();
         match &signature.self_kind {
-            ast::SelfKind::Borrow(type_kind) => params.push((
-                "self".to_owned(),
-                mir::TypeKind::Borrow(Box::new(type_kind.into_mir(module_id)), false),
-            )),
-            ast::SelfKind::MutBorrow(type_kind) => params.push((
-                "self".to_owned(),
-                mir::TypeKind::Borrow(Box::new(type_kind.into_mir(module_id)), true),
-            )),
-            ast::SelfKind::Owned(type_kind) => params.push(("self".to_owned(), type_kind.into_mir(module_id))),
+            ast::SelfKind::Borrow(ty) => params.push(mir::FunctionParam {
+                name: "self".to_owned(),
+                ty: mir::TypeKind::Borrow(Box::new(ty.0.into_mir(module_id)), false),
+                meta: ty.1.as_meta(module_id),
+            }),
+            ast::SelfKind::MutBorrow(ty) => params.push(mir::FunctionParam {
+                name: "self".to_owned(),
+                ty: mir::TypeKind::Borrow(Box::new(ty.0.into_mir(module_id)), true),
+                meta: ty.1.as_meta(module_id),
+            }),
+            ast::SelfKind::Owned(ty) => params.push(mir::FunctionParam {
+                name: "self".to_owned(),
+                ty: ty.0.into_mir(module_id),
+                meta: ty.1.as_meta(module_id),
+            }),
             ast::SelfKind::None => {}
         }
 
-        params.extend(
-            signature
-                .params
-                .iter()
-                .cloned()
-                .map(|p| (p.0, p.1 .0.into_mir(module_id))),
-        );
+        params.extend(signature.params.iter().cloned().map(|p| FunctionParam {
+            name: p.0,
+            ty: p.1 .0.into_mir(module_id),
+            meta: p.1 .1.as_meta(module_id),
+        }));
         mir::FunctionDefinition {
             name: signature.name.clone(),
             linkage_name: None,
diff --git a/reid/src/codegen/allocator.rs b/reid/src/codegen/allocator.rs
index 5809de3..0dd1754 100644
--- a/reid/src/codegen/allocator.rs
+++ b/reid/src/codegen/allocator.rs
@@ -7,7 +7,7 @@ use reid_lib::{
 
 use mir::{CustomTypeKey, FunctionCall, FunctionDefinitionKind, IfExpression, TypeKind, WhileStatement};
 
-use crate::mir;
+use crate::mir::{self, FunctionParam, Metadata};
 
 #[derive(Debug)]
 pub struct Allocator {
@@ -20,17 +20,13 @@ pub struct AllocatorScope<'ctx, 'a> {
 }
 
 impl Allocator {
-    pub fn from(
-        func: &FunctionDefinitionKind,
-        params: &Vec<(String, TypeKind)>,
-        scope: &mut AllocatorScope,
-    ) -> Allocator {
+    pub fn from(func: &FunctionDefinitionKind, params: &Vec<FunctionParam>, scope: &mut AllocatorScope) -> Allocator {
         func.allocate(scope, params)
     }
 
-    pub fn allocate(&mut self, name: &String, ty: &TypeKind) -> Option<InstructionValue> {
+    pub fn allocate(&mut self, meta: &Metadata, 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);
+        let val = allocs.find(|a| a.1 .0 == *meta && a.1 .1 == *ty);
         if let Some((i, _)) = val {
             self.allocations.remove(i);
         }
@@ -39,13 +35,13 @@ impl Allocator {
 }
 
 #[derive(Clone, Debug)]
-pub struct Allocation(String, TypeKind, InstructionValue);
+pub struct Allocation(Metadata, TypeKind, InstructionValue);
 
 impl mir::FunctionDefinitionKind {
     fn allocate<'ctx, 'a>(
         &self,
         scope: &mut AllocatorScope<'ctx, 'a>,
-        parameters: &Vec<(String, TypeKind)>,
+        parameters: &Vec<mir::FunctionParam>,
     ) -> Allocator {
         let mut allocated = Vec::new();
         match &self {
@@ -54,11 +50,11 @@ impl mir::FunctionDefinitionKind {
                     let allocation = scope
                         .block
                         .build_named(
-                            param.0.clone(),
-                            reid_lib::Instr::Alloca(param.1.get_type(scope.type_values)),
+                            param.name.clone(),
+                            reid_lib::Instr::Alloca(param.ty.get_type(scope.type_values)),
                         )
                         .unwrap();
-                    allocated.push(Allocation(param.0.clone(), param.1.clone(), allocation));
+                    allocated.push(Allocation(param.meta, param.ty.clone(), allocation));
                 }
                 allocated.extend(block.allocate(scope));
             }
@@ -103,7 +99,7 @@ impl mir::Statement {
                     )
                     .unwrap();
                 allocated.push(Allocation(
-                    named_variable_ref.1.clone(),
+                    named_variable_ref.2,
                     named_variable_ref.0.clone(),
                     allocation,
                 ));
@@ -195,7 +191,7 @@ impl mir::FunctionCall {
                     reid_lib::Instr::Alloca(self.return_type.get_type(scope.type_values)),
                 )
                 .unwrap();
-            allocated.push(Allocation(name.clone(), self.return_type.clone(), allocation));
+            allocated.push(Allocation(self.meta, self.return_type.clone(), allocation));
         }
 
         allocated
diff --git a/reid/src/codegen/intrinsics.rs b/reid/src/codegen/intrinsics.rs
index 0689c67..f054a76 100644
--- a/reid/src/codegen/intrinsics.rs
+++ b/reid/src/codegen/intrinsics.rs
@@ -2,7 +2,10 @@ use reid_lib::{builder::InstructionValue, CmpPredicate, ConstValue, Instr, Type}
 
 use crate::{
     codegen::{ErrorKind, StackValueKind},
-    mir::{BinaryOperator, BinopDefinition, CmpOperator, FunctionDefinition, FunctionDefinitionKind, TypeKind},
+    mir::{
+        BinaryOperator, BinopDefinition, CmpOperator, FunctionDefinition, FunctionDefinitionKind, FunctionParam,
+        TypeKind,
+    },
 };
 
 use super::scope::{Scope, StackValue};
@@ -53,7 +56,11 @@ pub fn get_intrinsic_assoc_func(ty: &TypeKind, name: &str) -> Option<FunctionDef
             is_pub: true,
             is_imported: false,
             return_type: TypeKind::UserPtr(Box::new(ty.clone())),
-            parameters: vec![(String::from("size"), TypeKind::U64)],
+            parameters: vec![FunctionParam {
+                name: String::from("size"),
+                ty: TypeKind::U64,
+                meta: Default::default(),
+            }],
             kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicAlloca(ty.clone()))),
         }),
         "null" => Some(FunctionDefinition {
@@ -74,9 +81,17 @@ where
     T: FnOnce(&mut Scope, InstructionValue, InstructionValue) -> InstructionValue,
 {
     BinopDefinition {
-        lhs: ("lhs".to_owned(), ty.clone()),
+        lhs: FunctionParam {
+            name: "lhs".to_owned(),
+            ty: ty.clone(),
+            meta: Default::default(),
+        },
         op,
-        rhs: ("rhs".to_owned(), ty.clone()),
+        rhs: FunctionParam {
+            name: "rhs".to_owned(),
+            ty: ty.clone(),
+            meta: Default::default(),
+        },
         return_type: ty.clone(),
         fn_kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicSimpleInstr(fun))),
         meta: Default::default(),
@@ -89,9 +104,17 @@ where
     T: FnOnce(&mut Scope, InstructionValue, InstructionValue) -> InstructionValue,
 {
     BinopDefinition {
-        lhs: ("lhs".to_owned(), lhs.clone()),
+        lhs: FunctionParam {
+            name: "lhs".to_owned(),
+            ty: lhs.clone(),
+            meta: Default::default(),
+        },
         op,
-        rhs: ("rhs".to_owned(), rhs.clone()),
+        rhs: FunctionParam {
+            name: "rhs".to_owned(),
+            ty: rhs.clone(),
+            meta: Default::default(),
+        },
         return_type: lhs.clone(),
         fn_kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicSimpleInstr(fun))),
         meta: Default::default(),
@@ -104,9 +127,17 @@ where
     T: FnOnce(&mut Scope, InstructionValue, InstructionValue) -> InstructionValue,
 {
     BinopDefinition {
-        lhs: ("lhs".to_owned(), ty.clone()),
+        lhs: FunctionParam {
+            name: "lhs".to_owned(),
+            ty: ty.clone(),
+            meta: Default::default(),
+        },
         op,
-        rhs: ("rhs".to_owned(), ty.clone()),
+        rhs: FunctionParam {
+            name: "rhs".to_owned(),
+            ty: ty.clone(),
+            meta: Default::default(),
+        },
         return_type: TypeKind::Bool,
         fn_kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicBooleanInstr(fun))),
         meta: Default::default(),
diff --git a/reid/src/codegen/mod.rs b/reid/src/codegen/mod.rs
index fea0dce..ff64402 100644
--- a/reid/src/codegen/mod.rs
+++ b/reid/src/codegen/mod.rs
@@ -19,8 +19,8 @@ use crate::{
         self,
         implement::TypeCategory,
         pass::{AssociatedFunctionKey, BinopKey},
-        CustomTypeKey, FunctionCall, FunctionDefinitionKind, NamedVariableRef, SourceModuleId, StructField, StructType,
-        TypeDefinition, TypeDefinitionKind, TypeKind, WhileStatement,
+        CustomTypeKey, FunctionCall, FunctionDefinitionKind, FunctionParam, NamedVariableRef, SourceModuleId,
+        StructField, StructType, TypeDefinition, TypeDefinitionKind, TypeKind, WhileStatement,
     },
     util::try_all,
 };
@@ -182,7 +182,7 @@ impl mir::Module {
             let param_types: Vec<Type> = function
                 .parameters
                 .iter()
-                .map(|(_, p)| p.get_type(&type_values))
+                .map(|FunctionParam { ty, .. }| ty.get_type(&type_values))
                 .collect();
 
             let is_main = self.is_main && function.name == "main";
@@ -222,7 +222,7 @@ impl mir::Module {
             let param_types: Vec<Type> = function
                 .parameters
                 .iter()
-                .map(|(_, p)| p.get_type(&type_values))
+                .map(|FunctionParam { ty, .. }| ty.get_type(&type_values))
                 .collect();
 
             let is_main = self.is_main && function.name == "main";
@@ -263,11 +263,11 @@ impl mir::Module {
         for binop in &self.binop_defs {
             let binop_fn_name = format!(
                 "binop.{}.{:?}.{}.{}",
-                binop.lhs.1, binop.op, binop.rhs.1, binop.return_type
+                binop.lhs.ty, binop.op, binop.rhs.ty, binop.return_type
             );
             binops.insert(
                 BinopKey {
-                    params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                    params: (binop.lhs.ty.clone(), binop.rhs.ty.clone()),
                     operator: binop.op,
                 },
                 StackBinopDefinition {
@@ -278,7 +278,7 @@ impl mir::Module {
                             let ir_function = module.function(
                                 &binop_fn_name,
                                 binop.return_type.get_type(&type_values),
-                                vec![binop.lhs.1.get_type(&type_values), binop.rhs.1.get_type(&type_values)],
+                                vec![binop.lhs.ty.get_type(&type_values), binop.rhs.ty.get_type(&type_values)],
                                 FunctionFlags {
                                     is_pub: binop.exported,
                                     is_imported: binop.exported,
@@ -342,7 +342,7 @@ impl mir::Module {
                         FunctionDefinitionKind::Extern(imported) => ScopeFunctionKind::UserGenerated(module.function(
                             &binop_fn_name,
                             binop.return_type.get_type(&type_values),
-                            vec![binop.lhs.1.get_type(&type_values), binop.rhs.1.get_type(&type_values)],
+                            vec![binop.lhs.ty.get_type(&type_values), binop.rhs.ty.get_type(&type_values)],
                             FunctionFlags {
                                 is_extern: true,
                                 is_imported: *imported,
@@ -482,7 +482,7 @@ impl FunctionDefinitionKind {
         name: String,
         is_pub: bool,
         scope: &mut Scope,
-        parameters: &Vec<(String, TypeKind)>,
+        parameters: &Vec<FunctionParam>,
         return_type: &TypeKind,
         ir_function: &Function,
         debug_location: Option<DebugLocation>,
@@ -526,25 +526,25 @@ impl FunctionDefinitionKind {
                 }
 
                 // Compile actual IR part
-                for (i, (p_name, p_ty)) in parameters.iter().enumerate() {
+                for (i, p) in parameters.iter().enumerate() {
                     // Codegen actual parameters
-                    let arg_name = format!("arg.{}", p_name);
+                    let arg_name = format!("arg.{}", p.name);
                     let param = scope
                         .block
                         .build_named(format!("{}.get", arg_name), Instr::Param(i))
                         .unwrap();
 
-                    let alloca = scope.allocate(&p_name, &p_ty).unwrap();
+                    let alloca = scope.allocate(&p.meta, &p.ty).unwrap();
 
                     scope
                         .block
                         .build_named(format!("{}.store", arg_name), Instr::Store(alloca, param))
                         .unwrap();
                     scope.stack_values.insert(
-                        p_name.clone(),
+                        p.name.clone(),
                         StackValue(
-                            StackValueKind::mutable(p_ty.is_mutable(), alloca),
-                            TypeKind::CodegenPtr(Box::new(p_ty.clone())),
+                            StackValueKind::mutable(p.ty.is_mutable(), alloca),
+                            TypeKind::CodegenPtr(Box::new(p.ty.clone())),
                         ),
                     );
                 }
@@ -644,11 +644,11 @@ impl mir::Statement {
         });
 
         match &self.0 {
-            mir::StmtKind::Let(NamedVariableRef(ty, name, _), mutable, expression) => {
+            mir::StmtKind::Let(NamedVariableRef(ty, name, meta), mutable, expression) => {
                 let value = expression.codegen(scope, &state)?.unwrap();
 
                 let alloca = scope
-                    .allocate(name, &value.1)
+                    .allocate(meta, &value.1)
                     .unwrap()
                     .maybe_location(&mut scope.block, location.clone());
 
@@ -1348,7 +1348,7 @@ fn codegen_function_call<'ctx, 'a>(
         let ptr = scope
             .allocator
             .borrow_mut()
-            .allocate(&call_name, &call.return_type)
+            .allocate(&call.meta, &call.return_type)
             .unwrap();
         scope
             .block
diff --git a/reid/src/codegen/scope.rs b/reid/src/codegen/scope.rs
index 043c111..19f20b5 100644
--- a/reid/src/codegen/scope.rs
+++ b/reid/src/codegen/scope.rs
@@ -10,7 +10,7 @@ use crate::{
     lexer::FullToken,
     mir::{
         pass::{AssociatedFunctionKey, BinopKey},
-        CustomTypeKey, SourceModuleId, TypeDefinition, TypeKind,
+        CustomTypeKey, FunctionParam, Metadata, SourceModuleId, TypeDefinition, TypeKind,
     },
 };
 
@@ -67,8 +67,8 @@ impl<'ctx, 'a> Scope<'ctx, 'a> {
         self.type_values.get(key).and_then(|v| self.types.get(v))
     }
 
-    pub fn allocate(&self, name: &String, ty: &TypeKind) -> Option<InstructionValue> {
-        self.allocator.borrow_mut().allocate(name, ty)
+    pub fn allocate(&self, meta: &Metadata, ty: &TypeKind) -> Option<InstructionValue> {
+        self.allocator.borrow_mut().allocate(meta, ty)
     }
 }
 
@@ -129,7 +129,7 @@ impl StackValueKind {
 }
 
 pub struct StackBinopDefinition<'ctx> {
-    pub(super) parameters: ((String, TypeKind), (String, TypeKind)),
+    pub(super) parameters: (FunctionParam, FunctionParam),
     pub(super) return_ty: TypeKind,
     pub(super) kind: ScopeFunctionKind<'ctx>,
 }
@@ -147,14 +147,14 @@ impl<'ctx> StackBinopDefinition<'ctx> {
         rhs: StackValue,
         scope: &mut Scope<'ctx, 'a>,
     ) -> Result<StackValue, ErrorKind> {
-        let (lhs, rhs) = if lhs.1 == self.parameters.0 .1 && rhs.1 == self.parameters.1 .1 {
+        let (lhs, rhs) = if lhs.1 == self.parameters.0.ty && rhs.1 == self.parameters.1.ty {
             (lhs, rhs)
         } else {
             (rhs, lhs)
         };
         let name = format!(
             "binop.{}.{}.{}.call",
-            self.parameters.0 .1, self.parameters.1 .1, self.return_ty
+            self.parameters.0.ty, self.parameters.1.ty, self.return_ty
         );
         self.kind.codegen(&name, &[lhs, rhs], &self.return_ty, None, scope)
     }
diff --git a/reid/src/lib.rs b/reid/src/lib.rs
index eb50c2b..e5e8ebb 100644
--- a/reid/src/lib.rs
+++ b/reid/src/lib.rs
@@ -131,11 +131,11 @@ pub fn perform_all_passes<'map>(
             binops
                 .set(
                     mir::pass::BinopKey {
-                        params: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
+                        params: (intrinsic.lhs.ty.clone(), intrinsic.rhs.ty.clone()),
                         operator: intrinsic.op,
                     },
                     mir::pass::ScopeBinopDef {
-                        hands: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
+                        hands: (intrinsic.lhs.ty.clone(), intrinsic.rhs.ty.clone()),
                         operator: intrinsic.op,
                         return_ty: intrinsic.return_type.clone(),
                     },
diff --git a/reid/src/mir/fmt.rs b/reid/src/mir/fmt.rs
index b9a6ed4..90c0c36 100644
--- a/reid/src/mir/fmt.rs
+++ b/reid/src/mir/fmt.rs
@@ -71,11 +71,11 @@ impl Display for BinopDefinition {
             f,
             "{}impl binop ({}: {:#}) {} ({}: {:#}) -> {:#} ",
             if self.exported { "exported " } else { "" },
-            self.lhs.0,
-            self.lhs.1,
+            self.lhs.name,
+            self.lhs.ty,
             self.op,
-            self.rhs.0,
-            self.rhs.1,
+            self.rhs.name,
+            self.rhs.ty,
             self.return_type
         )?;
         Display::fmt(&self.fn_kind, f)
@@ -132,7 +132,7 @@ impl Display for FunctionDefinition {
             self.name,
             self.parameters
                 .iter()
-                .map(|(n, t)| format!("{}: {:#}", n, t))
+                .map(|FunctionParam { name, ty, .. }| format!("{}: {:#}", name, ty))
                 .collect::<Vec<_>>()
                 .join(", "),
             self.return_type
diff --git a/reid/src/mir/linker.rs b/reid/src/mir/linker.rs
index 21cf679..2bfce10 100644
--- a/reid/src/mir/linker.rs
+++ b/reid/src/mir/linker.rs
@@ -11,8 +11,8 @@ use crate::{
     compile_module,
     error_raporting::{ErrorModules, ReidError},
     mir::{
-        pass::BinopKey, BinopDefinition, CustomTypeKey, FunctionDefinitionKind, SourceModuleId, TypeDefinition,
-        TypeKind,
+        pass::BinopKey, BinopDefinition, CustomTypeKey, FunctionDefinitionKind, FunctionParam, SourceModuleId,
+        TypeDefinition, TypeKind,
     },
     parse_module,
 };
@@ -220,10 +220,10 @@ impl<'map> Pass for LinkerPass<'map> {
                     imported_types.extend(types);
 
                     let mut param_tys = Vec::new();
-                    for (param_name, param_ty) in &func.parameters {
-                        let types = import_type(&param_ty, false);
+                    for param in &func.parameters {
+                        let types = import_type(&param.ty, false);
                         imported_types.extend(types);
-                        param_tys.push((param_name.clone(), param_ty.clone()));
+                        param_tys.push(param.clone());
                     }
 
                     importer_module.functions.push(FunctionDefinition {
@@ -241,11 +241,11 @@ impl<'map> Pass for LinkerPass<'map> {
                     imported_types.push((external_key, true));
 
                     for binop in &mut imported.binop_defs {
-                        if binop.lhs.1 != imported_ty && binop.rhs.1 != imported_ty {
+                        if binop.lhs.ty != imported_ty && binop.rhs.ty != imported_ty {
                             continue;
                         }
                         let binop_key = BinopKey {
-                            params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                            params: (binop.lhs.ty.clone(), binop.rhs.ty.clone()),
                             operator: binop.op,
                         };
                         if already_imported_binops.contains(&binop_key) {
@@ -309,10 +309,10 @@ impl<'map> Pass for LinkerPass<'map> {
                         imported_types.extend(types);
 
                         let mut param_tys = Vec::new();
-                        for (param_name, param_ty) in &func.parameters {
-                            let types = import_type(&param_ty, false);
+                        for param in &func.parameters {
+                            let types = import_type(&param.ty, false);
                             imported_types.extend(types);
-                            param_tys.push((param_name.clone(), param_ty.clone()));
+                            param_tys.push(param.clone());
                         }
 
                         importer_module.associated_functions.push((
@@ -424,7 +424,7 @@ impl<'map> Pass for LinkerPass<'map> {
             if let Some(extern_types) = extern_types {
                 function.return_type = function.return_type.update_imported(*extern_types, mod_id);
                 for param in function.parameters.iter_mut() {
-                    param.1 = param.1.update_imported(extern_types, mod_id);
+                    param.ty = param.ty.update_imported(extern_types, mod_id);
                 }
             }
         }
diff --git a/reid/src/mir/mod.rs b/reid/src/mir/mod.rs
index 5eb1b6b..198acf7 100644
--- a/reid/src/mir/mod.rs
+++ b/reid/src/mir/mod.rs
@@ -296,10 +296,17 @@ pub struct FunctionDefinition {
     /// Whether this module is from an external module, and has been imported
     pub is_imported: bool,
     pub return_type: TypeKind,
-    pub parameters: Vec<(String, TypeKind)>,
+    pub parameters: Vec<FunctionParam>,
     pub kind: FunctionDefinitionKind,
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct FunctionParam {
+    pub name: String,
+    pub ty: TypeKind,
+    pub meta: Metadata,
+}
+
 pub enum SelfKind {
     Borrow,
     MutBorrow,
@@ -378,9 +385,9 @@ pub enum TypeDefinitionKind {
 
 #[derive(Debug)]
 pub struct BinopDefinition {
-    pub lhs: (String, TypeKind),
+    pub lhs: FunctionParam,
     pub op: BinaryOperator,
-    pub rhs: (String, TypeKind),
+    pub rhs: FunctionParam,
     pub return_type: TypeKind,
     pub fn_kind: FunctionDefinitionKind,
     pub meta: Metadata,
diff --git a/reid/src/mir/pass.rs b/reid/src/mir/pass.rs
index 68c8562..d272f58 100644
--- a/reid/src/mir/pass.rs
+++ b/reid/src/mir/pass.rs
@@ -187,7 +187,7 @@ impl<Data: Clone + Default> Scope<Data> {
                     key.clone(),
                     ScopeFunction {
                         ret: func.return_type,
-                        params: func.parameters.iter().map(|(_, p)| p.clone()).collect(),
+                        params: func.parameters.iter().map(|p| p.ty.clone()).collect(),
                     },
                 )
                 .unwrap();
@@ -369,11 +369,11 @@ impl Context {
                 .binops
                 .set(
                     BinopKey {
-                        params: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
+                        params: (intrinsic.lhs.ty.clone(), intrinsic.rhs.ty.clone()),
                         operator: intrinsic.op,
                     },
                     ScopeBinopDef {
-                        hands: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
+                        hands: (intrinsic.lhs.ty.clone(), intrinsic.rhs.ty.clone()),
                         operator: intrinsic.op,
                         return_ty: intrinsic.return_type.clone(),
                     },
@@ -407,11 +407,11 @@ impl Module {
                 .binops
                 .set(
                     BinopKey {
-                        params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                        params: (binop.lhs.ty.clone(), binop.rhs.ty.clone()),
                         operator: binop.op,
                     },
                     ScopeBinopDef {
-                        hands: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                        hands: (binop.lhs.ty.clone(), binop.rhs.ty.clone()),
                         operator: binop.op,
                         return_ty: binop.return_type.clone(),
                     },
@@ -426,7 +426,7 @@ impl Module {
                     function.name.clone(),
                     ScopeFunction {
                         ret: function.return_type.clone(),
-                        params: function.parameters.iter().cloned().map(|v| v.1).collect(),
+                        params: function.parameters.iter().cloned().map(|v| v.ty).collect(),
                     },
                 )
                 .ok();
@@ -439,7 +439,7 @@ impl Module {
                     AssociatedFunctionKey(ty.clone(), function.name.clone()),
                     ScopeFunction {
                         ret: function.return_type.clone(),
-                        params: function.parameters.iter().cloned().map(|v| v.1).collect(),
+                        params: function.parameters.iter().cloned().map(|v| v.ty).collect(),
                     },
                 )
                 .ok();
@@ -466,9 +466,9 @@ impl FunctionDefinition {
             scope
                 .variables
                 .set(
-                    param.0.clone(),
+                    param.name.clone(),
                     ScopeVariable {
-                        ty: param.1.clone(),
+                        ty: param.ty.clone(),
                         mutable: false,
                     },
                 )
diff --git a/reid/src/mir/typecheck/typecheck.rs b/reid/src/mir/typecheck/typecheck.rs
index b73af26..4e44fae 100644
--- a/reid/src/mir/typecheck/typecheck.rs
+++ b/reid/src/mir/typecheck/typecheck.rs
@@ -112,7 +112,7 @@ impl BinopDefinition {
     fn typecheck(&mut self, typerefs: &TypeRefs, state: &mut TypecheckPassState) -> Result<TypeKind, ErrorKind> {
         for param in vec![&self.lhs, &self.rhs] {
             let param_t = state.or_else(
-                param.1.assert_known(state),
+                param.ty.assert_known(state),
                 TypeKind::Vague(Vague::Unknown),
                 self.signature(),
             );
@@ -120,13 +120,13 @@ impl BinopDefinition {
                 .scope
                 .variables
                 .set(
-                    param.0.clone(),
+                    param.name.clone(),
                     ScopeVariable {
                         ty: param_t.clone(),
                         mutable: param_t.is_mutable(),
                     },
                 )
-                .or(Err(ErrorKind::VariableAlreadyDefined(param.0.clone())));
+                .or(Err(ErrorKind::VariableAlreadyDefined(param.name.clone())));
             state.ok(res, self.signature());
         }
 
@@ -150,7 +150,7 @@ impl FunctionDefinition {
     fn typecheck(&mut self, typerefs: &TypeRefs, state: &mut TypecheckPassState) -> Result<TypeKind, ErrorKind> {
         for param in &self.parameters {
             let param_t = state.or_else(
-                param.1.assert_known(state),
+                param.ty.assert_known(state),
                 TypeKind::Vague(Vague::Unknown),
                 self.signature(),
             );
@@ -158,13 +158,13 @@ impl FunctionDefinition {
                 .scope
                 .variables
                 .set(
-                    param.0.clone(),
+                    param.name.clone(),
                     ScopeVariable {
                         ty: param_t.clone(),
                         mutable: param_t.is_mutable(),
                     },
                 )
-                .or(Err(ErrorKind::VariableAlreadyDefined(param.0.clone())));
+                .or(Err(ErrorKind::VariableAlreadyDefined(param.name.clone())));
             state.ok(res, self.signature());
         }
 
diff --git a/reid/src/mir/typecheck/typeinference.rs b/reid/src/mir/typecheck/typeinference.rs
index babb656..4bb0264 100644
--- a/reid/src/mir/typecheck/typeinference.rs
+++ b/reid/src/mir/typecheck/typeinference.rs
@@ -87,16 +87,16 @@ impl<'t> Pass for TypeInference<'t> {
         let mut seen_binops = HashSet::new();
         for binop in &module.binop_defs {
             let binop_key = BinopKey {
-                params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                params: (binop.lhs.ty.clone(), binop.rhs.ty.clone()),
                 operator: binop.op,
             };
-            if seen_binops.contains(&binop_key) || (binop.lhs == binop.rhs && binop.lhs.1.category().is_simple_maths())
+            if seen_binops.contains(&binop_key) || (binop.lhs == binop.rhs && binop.lhs.ty.category().is_simple_maths())
             {
                 state.note_errors(
                     &vec![ErrorKind::BinaryOpAlreadyDefined(
                         binop.op,
-                        binop.lhs.1.clone(),
-                        binop.rhs.1.clone(),
+                        binop.lhs.ty.clone(),
+                        binop.rhs.ty.clone(),
                     )],
                     binop.signature(),
                 );
@@ -107,7 +107,7 @@ impl<'t> Pass for TypeInference<'t> {
                     .set(
                         binop_key,
                         crate::mir::pass::ScopeBinopDef {
-                            hands: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                            hands: (binop.lhs.ty.clone(), binop.rhs.ty.clone()),
                             operator: binop.op,
                             return_ty: binop.return_type.clone(),
                         },
@@ -138,20 +138,20 @@ impl BinopDefinition {
     fn infer_types(&mut self, type_refs: &TypeRefs, state: &mut TypecheckPassState) -> Result<(), ErrorKind> {
         let scope_hints = ScopeTypeRefs::from(type_refs);
 
-        let lhs_ty = state.or_else(self.lhs.1.assert_unvague(), Vague(Unknown), self.signature());
+        let lhs_ty = state.or_else(self.lhs.ty.assert_unvague(), Vague(Unknown), self.signature());
         state.ok(
             scope_hints
-                .new_var(self.lhs.0.clone(), false, &lhs_ty)
-                .or(Err(ErrorKind::VariableAlreadyDefined(self.lhs.0.clone()))),
+                .new_var(self.lhs.name.clone(), false, &lhs_ty)
+                .or(Err(ErrorKind::VariableAlreadyDefined(self.lhs.name.clone()))),
             self.signature(),
         );
 
-        let rhs_ty = state.or_else(self.rhs.1.assert_unvague(), Vague(Unknown), self.signature());
+        let rhs_ty = state.or_else(self.rhs.ty.assert_unvague(), Vague(Unknown), self.signature());
 
         state.ok(
             scope_hints
-                .new_var(self.rhs.0.clone(), false, &rhs_ty)
-                .or(Err(ErrorKind::VariableAlreadyDefined(self.rhs.0.clone()))),
+                .new_var(self.rhs.name.clone(), false, &rhs_ty)
+                .or(Err(ErrorKind::VariableAlreadyDefined(self.rhs.name.clone()))),
             self.signature(),
         );
 
@@ -170,10 +170,10 @@ impl FunctionDefinition {
     fn infer_types(&mut self, type_refs: &TypeRefs, state: &mut TypecheckPassState) -> Result<(), ErrorKind> {
         let scope_refs = ScopeTypeRefs::from(type_refs);
         for param in &self.parameters {
-            let param_t = state.or_else(param.1.assert_unvague(), Vague(Unknown), self.signature());
+            let param_t = state.or_else(param.ty.assert_unvague(), Vague(Unknown), self.signature());
             let res = scope_refs
-                .new_var(param.0.clone(), false, &param_t)
-                .or(Err(ErrorKind::VariableAlreadyDefined(param.0.clone())));
+                .new_var(param.name.clone(), false, &param_t)
+                .or(Err(ErrorKind::VariableAlreadyDefined(param.name.clone())));
             state.ok(res, self.signature());
         }