Add type hints to basicblock.py, lowlevelil.py, architecture.py

1 files changed, 280 insertions, 274 deletions

diff --git a/python/mediumlevelil.py b/python/mediumlevelil.py
index c2e9a5eb..167930b6 100644
--- a/python/mediumlevelil.py
+++ b/python/mediumlevelil.py
@@ -20,23 +20,30 @@
 
 import ctypes
 import struct
-from typing import List
+from typing import Optional, List, Any, Union, Mapping, Generator, NewType
 
 # Binary Ninja components
-import binaryninja
-from binaryninja import _binaryninjacore as core
-from binaryninja.enums import MediumLevelILOperation, FunctionGraphType, ILBranchDependence
-from binaryninja import basicblock #required for MediumLevelILBasicBlock argument
-from binaryninja import function
-from binaryninja import types
-from binaryninja import lowlevelil
+from . import _binaryninjacore as core
+from .enums import MediumLevelILOperation, ILBranchDependence, DataFlowQueryOption
+from . import basicblock #required for MediumLevelILBasicBlock argument
+from . import function
+from . import types
+from . import lowlevelil
+from . import highlevelil
+from . import flowgraph
+from . import variable
+from . import architecture
+from . import binaryview
 
-# 2-3 compatibility
-from binaryninja import range
+OptionalTokens = Optional[List['function.InstructionTextToken']]
+ExpressionIndex = NewType('ExpressionIndex', int)
+InstructionIndex = NewType('InstructionIndex', int)
+MLILInstructionsType = Generator['MediumLevelILInstruction', None, None]
+MLILBasicBlocksType = Generator['MediumLevelILBasicBlock', None, None]
 
 
 class SSAVariable(object):
-	def __init__(self, var, version):
+	def __init__(self, var:'variable.Variable', version:int):
 		self._var = var
 		self._version = version
 
@@ -57,26 +64,24 @@ class SSAVariable(object):
 		return hash((self._var, self._version))
 
 	@property
-	def var(self):
-		""" """
+	def var(self) -> 'variable.Variable':
 		return self._var
 
 	@var.setter
-	def var(self, value):
+	def var(self, value:'variable.Variable') -> None:
 		self._var = value
 
 	@property
-	def version(self):
-		""" """
+	def version(self) -> int:
 		return self._version
 
 	@version.setter
-	def version(self, value):
+	def version(self, value=int) -> None:
 		self._version = value
 
 
 class MediumLevelILLabel(object):
-	def __init__(self, handle = None):
+	def __init__(self, handle:Optional[core.BNMediumLevelILLabel]=None):
 		if handle is None:
 			self.handle = (core.BNMediumLevelILLabel * 1)()
 			core.BNMediumLevelILInitLabel(self.handle)
@@ -85,7 +90,7 @@ class MediumLevelILLabel(object):
 
 
 class MediumLevelILOperationAndSize(object):
-	def __init__(self, operation, size):
+	def __init__(self, operation:MediumLevelILOperation, size:int):
 		self._operation = operation
 		self._size = size
 
@@ -110,13 +115,11 @@ class MediumLevelILOperationAndSize(object):
 		return hash((self._operation, self._size))
 
 	@property
-	def operation(self):
-		""" """
+	def operation(self) -> MediumLevelILOperation:
 		return self._operation
 
 	@property
-	def size(self):
-		""" """
+	def size(self) -> int:
 		return self._size
 
 
@@ -261,7 +264,7 @@ class MediumLevelILInstruction(object):
 		MediumLevelILOperation.MLIL_MEM_PHI: [("dest_memory", "int"), ("src_memory", "int_list")]
 	}
 
-	def __init__(self, func, expr_index, instr_index=None):
+	def __init__(self, func:'MediumLevelILFunction', expr_index:ExpressionIndex, instr_index:InstructionIndex=None):
 		instr = core.BNGetMediumLevelILByIndex(func.handle, expr_index)
 		self._function = func
 		self._expr_index = expr_index
@@ -274,10 +277,11 @@ class MediumLevelILInstruction(object):
 		self._address = instr.address
 		self._source_operand = instr.sourceOperand
 		operands = MediumLevelILInstruction.ILOperations[instr.operation]
-		self._operands = []
+		self._operands:List[Any] = []
 		i = 0
 		for operand in operands:
 			name, operand_type = operand
+			value = None
 			if operand_type == "int":
 				value = instr.operands[i]
 				value = (value & ((1 << 63) - 1)) - (value & (1 << 63))
@@ -291,16 +295,17 @@ class MediumLevelILInstruction(object):
 			elif operand_type == "expr":
 				value = MediumLevelILInstruction(func, instr.operands[i])
 			elif operand_type == "intrinsic":
+				assert func.arch is not None, "Attempting to create ILInstrinsice from function with no Architecture"
 				value = lowlevelil.ILIntrinsic(func.arch, instr.operands[i])
 			elif operand_type == "var":
-				value = function.Variable.from_identifier(self._function.source_function, instr.operands[i])
+				value = variable.Variable.from_identifier(self._function.source_function, instr.operands[i])
 			elif operand_type == "var_ssa":
-				var = function.Variable.from_identifier(self._function.source_function, instr.operands[i])
+				var = variable.Variable.from_identifier(self._function.source_function, instr.operands[i])
 				version = instr.operands[i + 1]
 				i += 1
 				value = SSAVariable(var, version)
 			elif operand_type == "var_ssa_dest_and_src":
-				var = function.Variable.from_identifier(self._function.source_function, instr.operands[i])
+				var = variable.Variable.from_identifier(self._function.source_function, instr.operands[i])
 				dest_version = instr.operands[i + 1]
 				src_version = instr.operands[i + 2]
 				i += 2
@@ -311,6 +316,7 @@ class MediumLevelILInstruction(object):
 			elif operand_type == "int_list":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
 				value = []
 				for j in range(count.value):
 					value.append(operand_list[j])
@@ -318,25 +324,28 @@ class MediumLevelILInstruction(object):
 			elif operand_type == "var_list":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
 				i += 1
 				value = []
 				for j in range(count.value):
-					value.append(function.Variable.from_identifier(self._function.source_function, operand_list[j]))
+					value.append(variable.Variable.from_identifier(self._function.source_function, operand_list[j]))
 				core.BNMediumLevelILFreeOperandList(operand_list)
 			elif operand_type == "var_ssa_list":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
 				i += 1
 				value = []
 				for j in range(count.value // 2):
 					var_id = operand_list[j * 2]
 					var_version = operand_list[(j * 2) + 1]
-					value.append(SSAVariable(function.Variable.from_identifier(self._function.source_function,
+					value.append(SSAVariable(variable.Variable.from_identifier(self._function.source_function,
 						var_id), var_version))
 				core.BNMediumLevelILFreeOperandList(operand_list)
 			elif operand_type == "expr_list":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
 				i += 1
 				value = []
 				for j in range(count.value):
@@ -345,6 +354,7 @@ class MediumLevelILInstruction(object):
 			elif operand_type == "target_map":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
 				i += 1
 				value = {}
 				for j in range(count.value // 2):
@@ -368,27 +378,27 @@ class MediumLevelILInstruction(object):
 	def __repr__(self):
 		return "<il: %s>" % str(self)
 
-	def __eq__(self, other):
+	def __eq__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
 		return self._function == other.function and self._expr_index == other.expr_index
 
-	def __lt__(self, other):
+	def __lt__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
 		return self._function == other.function and self.expr_index < other.expr_index
 
-	def __le__(self, other):
+	def __le__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
 		return self._function == other.function and self.expr_index <= other.expr_index
 
-	def __gt__(self, other):
+	def __gt__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
 		return self._function == other.function and self.expr_index > other.expr_index
 
-	def __ge__(self, other):
+	def __ge__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
 		return self._function == other.function and self.expr_index >= other.expr_index
@@ -397,10 +407,12 @@ class MediumLevelILInstruction(object):
 		return hash((self._instr_index, self._function))
 
 	@property
-	def tokens(self):
+	def tokens(self) -> OptionalTokens:
 		"""MLIL tokens (read-only)"""
 		count = ctypes.c_ulonglong()
 		tokens = ctypes.POINTER(core.BNInstructionTextToken)()
+		if self._function.arch is None:
+			raise Exception("Attempting to get tokens for MLIL Function with no Architecture set")
 		if ((self._instr_index is not None) and (self._function.source_function is not None) and
 			(self._expr_index == core.BNGetMediumLevelILIndexForInstruction(self._function.handle, self._instr_index))):
 			if not core.BNGetMediumLevelILInstructionText(self._function.handle, self._function.source_function.handle,
@@ -410,47 +422,55 @@ class MediumLevelILInstruction(object):
 			if not core.BNGetMediumLevelILExprText(self._function.handle, self._function.arch.handle,
 				self._expr_index, tokens, count, None):
 				return None
-		result = binaryninja.function.InstructionTextToken.get_instruction_lines(tokens, count.value)
+		result = function.InstructionTextToken._from_core_struct(tokens, count.value)
 		core.BNFreeInstructionText(tokens, count.value)
 		return result
 
 	@property
-	def il_basic_block(self):
+	def il_basic_block(self) -> 'MediumLevelILBasicBlock':
 		"""IL basic block object containing this expression (read-only) (only available on finalized functions)"""
-		return MediumLevelILBasicBlock(self._function.source_function.view, core.BNGetMediumLevelILBasicBlockForInstruction(self._function.handle, self._instr_index), self._function)
+		core_block = core.BNGetMediumLevelILBasicBlockForInstruction(self._function.handle, self._instr_index)
+		assert core_block is not None
+		assert self._function.source_function is not None
+		return MediumLevelILBasicBlock(core_block, self._function, self._function.source_function.view)
 
 	@property
-	def ssa_form(self):
+	def ssa_form(self) -> 'MediumLevelILInstruction':
 		"""SSA form of expression (read-only)"""
-		return MediumLevelILInstruction(self._function.ssa_form,
+		ssa_func = self._function.ssa_form
+		assert ssa_func is not None
+		return MediumLevelILInstruction(ssa_func,
 			core.BNGetMediumLevelILSSAExprIndex(self._function.handle, self._expr_index))
 
 	@property
-	def non_ssa_form(self):
+	def non_ssa_form(self) -> 'MediumLevelILInstruction':
 		"""Non-SSA form of expression (read-only)"""
-		return MediumLevelILInstruction(self._function.non_ssa_form,
+		non_ssa_func = self._function.non_ssa_form
+		assert non_ssa_func is not None
+		return MediumLevelILInstruction(non_ssa_func,
 			core.BNGetMediumLevelILNonSSAExprIndex(self._function.handle, self._expr_index))
 
 	@property
-	def value(self):
+	def value(self) -> variable.RegisterValue:
 		"""Value of expression if constant or a known value (read-only)"""
 		value = core.BNGetMediumLevelILExprValue(self._function.handle, self._expr_index)
-		result = function.RegisterValue(self._function.arch, value)
+		result = variable.RegisterValue(self._function.arch, value)
 		return result
 
 	@property
-	def possible_values(self):
+	def possible_values(self) -> variable.PossibleValueSet:
 		"""Possible values of expression using path-sensitive static data flow analysis (read-only)"""
 		value = core.BNGetMediumLevelILPossibleExprValues(self._function.handle, self._expr_index, None, 0)
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	@property
-	def branch_dependence(self):
+	def branch_dependence(self) -> Mapping[int, ILBranchDependence]:
 		"""Set of branching instructions that must take the true or false path to reach this instruction"""
 		count = ctypes.c_ulonglong()
 		deps = core.BNGetAllMediumLevelILBranchDependence(self._function.handle, self._instr_index, count)
+		assert deps is not None, "core.BNGetAllMediumLevelILBranchDependence returned None"
 		result = {}
 		for i in range(0, count.value):
 			result[deps[i].branch] = ILBranchDependence(deps[i].dependence)
@@ -458,54 +478,58 @@ class MediumLevelILInstruction(object):
 		return result
 
 	@property
-	def low_level_il(self):
+	def low_level_il(self) -> Optional['lowlevelil.LowLevelILInstruction']:
 		"""Low level IL form of this expression"""
 		expr = self._function.get_low_level_il_expr_index(self._expr_index)
-		if expr is None:
+		if expr is None or self._function.low_level_il is None:
 			return None
 		return lowlevelil.LowLevelILInstruction(self._function.low_level_il.ssa_form, expr)
 
 	@property
-	def llil(self):
+	def llil(self) -> Optional['lowlevelil.LowLevelILInstruction']:
 		"""Alias for low_level_il"""
 		return self.low_level_il
 
 	@property
-	def llils(self):
+	def llils(self) -> List['lowlevelil.LowLevelILInstruction']:
 		exprs = self._function.get_low_level_il_expr_indexes(self.expr_index)
+		if self._function.low_level_il is None:
+			return []
 		result = []
 		for expr in exprs:
 			result.append(lowlevelil.LowLevelILInstruction(self._function.low_level_il.ssa_form, expr))
 		return result
 
 	@property
-	def high_level_il(self):
+	def high_level_il(self) -> Optional[highlevelil.HighLevelILInstruction]:
 		"""High level IL form of this expression"""
 		expr = self._function.get_high_level_il_expr_index(self._expr_index)
-		if expr is None:
+		if expr is None or self._function.high_level_il is None:
 			return None
-		return binaryninja.highlevelil.HighLevelILInstruction(self._function.high_level_il, expr)
+		return highlevelil.HighLevelILInstruction(self._function.high_level_il, expr)
 
 	@property
-	def hlil(self):
+	def hlil(self) -> Optional[highlevelil.HighLevelILInstruction]:
 		"""Alias for high_level_il"""
 		return self.high_level_il
 
 	@property
-	def hlils(self):
+	def hlils(self) -> List[highlevelil.HighLevelILInstruction]:
 		exprs = self._function.get_high_level_il_expr_indexes(self.expr_index)
 		result = []
+		if self._function.high_level_il is None:
+			return result
 		for expr in exprs:
-			result.append(binaryninja.highlevelil.HighLevelILInstruction(self._function.high_level_il, expr))
+			result.append(highlevelil.HighLevelILInstruction(self._function.high_level_il, expr))
 		return result
 
 	@property
-	def ssa_memory_version(self):
+	def ssa_memory_version(self) -> int:
 		"""Version of active memory contents in SSA form for this instruction"""
 		return core.BNGetMediumLevelILSSAMemoryVersionAtILInstruction(self._function.handle, self._instr_index)
 
 	@property
-	def prefix_operands(self):
+	def prefix_operands(self) -> List[Any]:
 		"""All operands in the expression tree in prefix order"""
 		result = [MediumLevelILOperationAndSize(self._operation, self._size)]
 		for operand in self._operands:
@@ -516,7 +540,7 @@ class MediumLevelILInstruction(object):
 		return result
 
 	@property
-	def postfix_operands(self):
+	def postfix_operands(self) -> List[Any]:
 		"""All operands in the expression tree in postfix order"""
 		result = []
 		for operand in self._operands:
@@ -528,60 +552,62 @@ class MediumLevelILInstruction(object):
 		return result
 
 	@property
-	def vars_written(self):
+	def vars_written(self) -> List[Union[variable.Variable, SSAVariable]]:
 		"""List of variables written by instruction"""
+		# We use self.__dict__ directly to work around the linter
 		if self._operation in [MediumLevelILOperation.MLIL_SET_VAR, MediumLevelILOperation.MLIL_SET_VAR_FIELD,
 			MediumLevelILOperation.MLIL_SET_VAR_SSA, MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD,
 			MediumLevelILOperation.MLIL_SET_VAR_ALIASED, MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD,
 			MediumLevelILOperation.MLIL_VAR_PHI]:
 			return [self.dest]
 		elif self._operation in [MediumLevelILOperation.MLIL_SET_VAR_SPLIT, MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA]:
-			return [self.high, self.low]
+			return [self.__dict__['high'], self.__dict__['low']]
 		elif self._operation in [MediumLevelILOperation.MLIL_CALL, MediumLevelILOperation.MLIL_SYSCALL, MediumLevelILOperation.MLIL_TAILCALL]:
-			return self.output
+			return self.__dict__['output']
 		elif self._operation in [MediumLevelILOperation.MLIL_CALL_UNTYPED, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED,
 			MediumLevelILOperation.MLIL_CALL_SSA, MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA,
 			MediumLevelILOperation.MLIL_SYSCALL_SSA, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA,
 			MediumLevelILOperation.MLIL_TAILCALL_SSA, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED_SSA]:
-			return self.output.vars_written
+			return self.__dict__['output'].vars_written
 		elif self._operation in [MediumLevelILOperation.MLIL_CALL_OUTPUT, MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA]:
-			return self.dest
+			return self.__dict__['dest']
 		return []
 
 	@property
-	def vars_read(self):
+	def vars_read(self) -> List[variable.Variable]:
 		"""List of variables read by instruction"""
+		# We use self.__dict__ directly to work around the linter
 		if self._operation in [MediumLevelILOperation.MLIL_SET_VAR, MediumLevelILOperation.MLIL_SET_VAR_FIELD,
 			MediumLevelILOperation.MLIL_SET_VAR_SPLIT, MediumLevelILOperation.MLIL_SET_VAR_SSA,
 			MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA, MediumLevelILOperation.MLIL_SET_VAR_ALIASED]:
-			return self.src.vars_read
+			return self.__dict__['src'].vars_read
 		elif self._operation in [MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD,
 			MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD]:
-			return [self.prev] + self.src.vars_read
+			return [self.__dict__['prev']] + self.__dict__['src'].vars_read
 		elif self._operation in [MediumLevelILOperation.MLIL_CALL, MediumLevelILOperation.MLIL_SYSCALL, MediumLevelILOperation.MLIL_TAILCALL,
 			MediumLevelILOperation.MLIL_CALL_SSA, MediumLevelILOperation.MLIL_SYSCALL_SSA, MediumLevelILOperation.MLIL_TAILCALL_SSA]:
 			result = []
-			for param in self.params:
+			for param in self.__dict__['params']:
 				result += param.vars_read
 			return result
 		elif self._operation in [MediumLevelILOperation.MLIL_CALL_UNTYPED, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED,
 			MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED_SSA]:
-			return self.params.vars_read
+			return self.__dict__['params'].vars_read
 		elif self._operation in [MediumLevelILOperation.MLIL_CALL_PARAM, MediumLevelILOperation.MLIL_CALL_PARAM_SSA,
 			MediumLevelILOperation.MLIL_VAR_PHI]:
-			return self.src
+			return self.__dict__['src']
 		elif self._operation in [MediumLevelILOperation.MLIL_CALL_OUTPUT, MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA]:
 			return []
 		result = []
 		for operand in self._operands:
-			if (isinstance(operand, function.Variable)) or (isinstance(operand, SSAVariable)):
+			if (isinstance(operand, variable.Variable)) or (isinstance(operand, SSAVariable)):
 				result.append(operand)
 			elif isinstance(operand, MediumLevelILInstruction):
 				result += operand.vars_read
 		return result
 
 	@property
-	def expr_type(self):
+	def expr_type(self) -> Optional['types.Type']:
 		"""Type of expression"""
 		result = core.BNGetMediumLevelILExprType(self._function.handle, self._expr_index)
 		if result.type:
@@ -591,18 +617,18 @@ class MediumLevelILInstruction(object):
 			return types.Type(result.type, platform = platform, confidence = result.confidence)
 		return None
 
-	def get_possible_values(self, options = []):
+	def get_possible_values(self, options:List[DataFlowQueryOption]=[]) -> variable.PossibleValueSet:
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
 		for option in options:
 			option_array[idx] = option
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleExprValues(self._function.handle, self._expr_index, option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_ssa_var_possible_values(self, ssa_var, options = []):
+	def get_ssa_var_possible_values(self, ssa_var:SSAVariable, options:List[DataFlowQueryOption]=[]):
 		var_data = core.BNVariable()
 		var_data.type = ssa_var.var.source_type
 		var_data.index = ssa_var.var.index
@@ -614,44 +640,45 @@ class MediumLevelILInstruction(object):
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleSSAVarValues(self._function.handle, var_data, ssa_var.version,
 			self._instr_index, option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_ssa_var_version(self, var):
+	def get_ssa_var_version(self, var:variable.Variable) -> int:
 		var_data = core.BNVariable()
 		var_data.type = var.source_type
 		var_data.index = var.index
 		var_data.storage = var.storage
 		return core.BNGetMediumLevelILSSAVarVersionAtILInstruction(self._function.handle, var_data, self._instr_index)
 
-	def get_var_for_reg(self, reg):
+	def get_var_for_reg(self, reg:'architecture.RegisterType') -> variable.Variable:
 		reg = self._function.arch.get_reg_index(reg)
 		result = core.BNGetMediumLevelILVariableForRegisterAtInstruction(self._function.handle, reg, self._instr_index)
-		return function.Variable(self._function.source_function, result.type, result.index, result.storage)
+		return variable.Variable(self._function.source_function, result.type, result.index, result.storage)
 
-	def get_var_for_flag(self, flag):
+	def get_var_for_flag(self, flag:'architecture.FlagType') -> variable.Variable:
 		flag = self._function.arch.get_flag_index(flag)
 		result = core.BNGetMediumLevelILVariableForFlagAtInstruction(self._function.handle, flag, self._instr_index)
-		return function.Variable(self._function.source_function, result.type, result.index, result.storage)
+		return variable.Variable(self._function.source_function, result.type, result.index, result.storage)
 
-	def get_var_for_stack_location(self, offset):
+	def get_var_for_stack_location(self, offset:int) -> variable.Variable:
 		result = core.BNGetMediumLevelILVariableForStackLocationAtInstruction(self._function.handle, offset, self._instr_index)
-		return function.Variable(self._function.source_function, result.type, result.index, result.storage)
+		return variable.Variable(self._function.source_function, result.type, result.index, result.storage)
 
-	def get_reg_value(self, reg):
+	def get_reg_value(self, reg:'architecture.RegisterType') -> 'variable.RegisterValue':
 		reg = self._function.arch.get_reg_index(reg)
 		value = core.BNGetMediumLevelILRegisterValueAtInstruction(self._function.handle, reg, self._instr_index)
-		result = function.RegisterValue(self._function.arch, value)
+		result = variable.RegisterValue(self._function.arch, value)
 		return result
 
-	def get_reg_value_after(self, reg):
+	def get_reg_value_after(self, reg:'architecture.RegisterType') -> 'variable.RegisterValue':
 		reg = self._function.arch.get_reg_index(reg)
 		value = core.BNGetMediumLevelILRegisterValueAfterInstruction(self._function.handle, reg, self._instr_index)
-		result = function.RegisterValue(self._function.arch, value)
+		result = variable.RegisterValue(self._function.arch, value)
 		return result
 
-	def get_possible_reg_values(self, reg, options = []):
+	def get_possible_reg_values(self, reg:'architecture.RegisterType',
+		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
 		reg = self._function.arch.get_reg_index(reg)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
@@ -660,11 +687,12 @@ class MediumLevelILInstruction(object):
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleRegisterValuesAtInstruction(self._function.handle, reg, self._instr_index,
 			option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_possible_reg_values_after(self, reg, options = []):
+	def get_possible_reg_values_after(self, reg:'architecture.RegisterType',
+		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
 		reg = self._function.arch.get_reg_index(reg)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
@@ -673,23 +701,24 @@ class MediumLevelILInstruction(object):
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(self._function.handle, reg, self._instr_index,
 			option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_flag_value(self, flag):
+	def get_flag_value(self, flag:'architecture.FlagType') -> 'variable.RegisterValue':
 		flag = self._function.arch.get_flag_index(flag)
 		value = core.BNGetMediumLevelILFlagValueAtInstruction(self._function.handle, flag, self._instr_index)
-		result = function.RegisterValue(self._function.arch, value)
+		result = variable.RegisterValue(self._function.arch, value)
 		return result
 
-	def get_flag_value_after(self, flag):
+	def get_flag_value_after(self, flag:'architecture.FlagType') -> 'variable.RegisterValue':
 		flag = self._function.arch.get_flag_index(flag)
 		value = core.BNGetMediumLevelILFlagValueAfterInstruction(self._function.handle, flag, self._instr_index)
-		result = function.RegisterValue(self._function.arch, value)
+		result = variable.RegisterValue(self._function.arch, value)
 		return result
 
-	def get_possible_flag_values(self, flag, options = []):
+	def get_possible_flag_values(self, flag:'architecture.FlagType',
+		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
 		flag = self._function.arch.get_flag_index(flag)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
@@ -698,11 +727,12 @@ class MediumLevelILInstruction(object):
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleFlagValuesAtInstruction(self._function.handle, flag, self._instr_index,
 			option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_possible_flag_values_after(self, flag, options = []):
+	def get_possible_flag_values_after(self, flag:'architecture.FlagType',
+		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
 		flag = self._function.arch.get_flag_index(flag)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
@@ -711,21 +741,22 @@ class MediumLevelILInstruction(object):
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleFlagValuesAfterInstruction(self._function.handle, flag, self._instr_index,
 			option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_stack_contents(self, offset, size):
+	def get_stack_contents(self, offset:int, size:int) -> 'variable.RegisterValue':
 		value = core.BNGetMediumLevelILStackContentsAtInstruction(self._function.handle, offset, size, self._instr_index)
-		result = function.RegisterValue(self._function.arch, value)
+		result = variable.RegisterValue(self._function.arch, value)
 		return result
 
-	def get_stack_contents_after(self, offset, size):
+	def get_stack_contents_after(self, offset:int, size:int) -> 'variable.RegisterValue':
 		value = core.BNGetMediumLevelILStackContentsAfterInstruction(self._function.handle, offset, size, self._instr_index)
-		result = function.RegisterValue(self._function.arch, value)
+		result = variable.RegisterValue(self._function.arch, value)
 		return result
 
-	def get_possible_stack_contents(self, offset, size, options = []):
+	def get_possible_stack_contents(self, offset:int, size:int,
+		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
 		for option in options:
@@ -733,11 +764,12 @@ class MediumLevelILInstruction(object):
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleStackContentsAtInstruction(self._function.handle, offset, size, self._instr_index,
 			option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_possible_stack_contents_after(self, offset, size, options = []):
+	def get_possible_stack_contents_after(self, offset:int, size:int,
+		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
 		for option in options:
@@ -745,51 +777,43 @@ class MediumLevelILInstruction(object):
 			idx += 1
 		value = core.BNGetMediumLevelILPossibleStackContentsAfterInstruction(self._function.handle, offset, size, self._instr_index,
 			option_array, len(options))
-		result = function.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self._function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
-	def get_branch_dependence(self, branch_instr):
+	def get_branch_dependence(self, branch_instr:int) -> ILBranchDependence:
 		return ILBranchDependence(core.BNGetMediumLevelILBranchDependence(self._function.handle, self._instr_index, branch_instr))
 
 	@property
-	def function(self):
-		""" """
+	def function(self) -> 'MediumLevelILFunction':
 		return self._function
 
 	@property
-	def expr_index(self):
-		""" """
+	def expr_index(self) -> ExpressionIndex:
 		return self._expr_index
 
 	@property
-	def instr_index(self):
-		""" """
+	def instr_index(self) -> InstructionIndex:
 		return self._instr_index
 
 	@property
-	def operation(self):
-		""" """
+	def operation(self) -> MediumLevelILOperation:
 		return self._operation
 
 	@property
-	def size(self):
-		""" """
+	def size(self) -> int:
 		return self._size
 
 	@property
-	def address(self):
-		""" """
+	def address(self) -> int:
 		return self._address
 
 	@property
-	def source_operand(self):
-		""" """
+	def source_operand(self) -> ExpressionIndex:
 		return self._source_operand
 
 	@property
-	def operands(self):
-		""" """
+	def operands(self) -> List[Any]:
 		return self._operands
 
 
@@ -805,7 +829,6 @@ class MediumLevelILExpr(object):
 
 	@property
 	def index(self):
-		""" """
 		return self._index
 
 	@index.setter
@@ -815,27 +838,33 @@ class MediumLevelILExpr(object):
 
 class MediumLevelILFunction(object):
 	"""
-	``class MediumLevelILFunction`` contains the list of MediumLevelILExpr objects that make up a binaryninja.function. MediumLevelILExpr
+	``class MediumLevelILFunction`` contains the list of MediumLevelILExpr objects that make up a function. MediumLevelILExpr
 	objects can be added to the MediumLevelILFunction by calling :func:`append` and passing the result of the various class
 	methods which return MediumLevelILExpr objects.
 	"""
-	def __init__(self, arch = None, handle = None, source_func = None):
-		self._arch = arch
-		self._source_function = source_func
+	def __init__(self, arch:Optional['architecture.Architecture']=None,
+		handle:Optional[core.BNMediumLevelILFunction]=None, source_func:Optional['function.Function']=None):
+		_arch = arch
+		_source_function = source_func
 		if handle is not None:
-			self.handle = core.handle_of_type(handle, core.BNMediumLevelILFunction)
-			if self._source_function is None:
-				self._source_function = binaryninja.function.Function(handle = core.BNGetMediumLevelILOwnerFunction(self.handle))
-			if self._arch is None:
-				self._arch = self._source_function.arch
+			_handle = core.handle_of_type(handle, core.BNMediumLevelILFunction)
+			if _source_function is None:
+				_source_function = function.Function(handle = core.BNGetMediumLevelILOwnerFunction(_handle))
+			if _arch is None:
+				_arch = _source_function.arch
 		else:
-			if self._source_function is None:
-				self.handle = None
+			if _source_function is None:
 				raise ValueError("IL functions must be created with an associated function")
-			if self._arch is None:
-				self._arch = self._source_function.arch
-			func_handle = self._source_function.handle
-			self.handle = core.BNCreateMediumLevelILFunction(arch.handle, func_handle)
+			if _arch is None:
+				_arch = _source_function.arch
+			func_handle = _source_function.handle
+			_handle = core.BNCreateMediumLevelILFunction(self.arch.handle, func_handle)
+		assert _source_function is not None
+		assert _arch is not None
+		assert _handle is not None
+		self.handle = _handle
+		self._arch = _arch
+		self._source_function = _source_function
 
 	def __del__(self):
 		if self.handle is not None:
@@ -884,52 +913,59 @@ class MediumLevelILFunction(object):
 	def __iter__(self):
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetMediumLevelILBasicBlockList(self.handle, count)
+		assert blocks is not None, "core.BNGetMediumLevelILBasicBlockList returned None"
 		view = None
 		if self._source_function is not None:
 			view = self._source_function.view
 		try:
 			for i in range(0, count.value):
-				yield MediumLevelILBasicBlock(view, core.BNNewBasicBlockReference(blocks[i]), self)
+				core_block = core.BNNewBasicBlockReference(blocks[i])
+				assert core_block is not None, "Got None from core.BNNewBasicBlockReference"
+				yield MediumLevelILBasicBlock(core_block, self, view)
 		finally:
 			core.BNFreeBasicBlockList(blocks, count.value)
 
 	@property
-	def current_address(self):
+	def current_address(self) -> int:
 		"""Current IL Address (read/write)"""
 		return core.BNMediumLevelILGetCurrentAddress(self.handle)
 
 	@current_address.setter
-	def current_address(self, value):
+	def current_address(self, value:int) -> None:
 		core.BNMediumLevelILSetCurrentAddress(self.handle, self._arch.handle, value)
 
-	def set_current_address(self, value, arch = None):
-		if arch is None:
-			arch = self._arch
-		core.BNMediumLevelILSetCurrentAddress(self.handle, arch.handle, value)
+	def set_current_address(self, value:int, arch:Optional['architecture.Architecture']=None) -> None:
+		_arch = arch
+		if _arch is None:
+			_arch = self._arch
+		core.BNMediumLevelILSetCurrentAddress(self.handle, _arch.handle, value)
 
 	@property
-	def basic_blocks(self):
+	def basic_blocks(self) -> Generator['MediumLevelILBasicBlock', None, None]:
 		"""list of MediumLevelILBasicBlock objects (read-only)"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetMediumLevelILBasicBlockList(self.handle, count)
-		result = []
+		assert blocks is not None, "core.BNGetMediumLevelILBasicBlockList returned None"
 		view = None
 		if self._source_function is not None:
 			view = self._source_function.view
-		for i in range(0, count.value):
-			result.append(MediumLevelILBasicBlock(view, core.BNNewBasicBlockReference(blocks[i]), self))
-		core.BNFreeBasicBlockList(blocks, count.value)
-		return result
+		try:
+			for i in range(0, count.value):
+				core_block = core.BNNewBasicBlockReference(blocks[i])
+				assert core_block is not None
+				yield MediumLevelILBasicBlock(core_block, self, view)
+		finally:
+			core.BNFreeBasicBlockList(blocks, count.value)
 
 	@property
-	def instructions(self):
+	def instructions(self) -> Generator[MediumLevelILInstruction, None, None]:
 		"""A generator of mlil instructions of the current function"""
 		for block in self.basic_blocks:
 			for i in block:
 				yield i
 
 	@property
-	def ssa_form(self):
+	def ssa_form(self) -> Optional['MediumLevelILFunction']:
 		"""Medium level IL in SSA form (read-only)"""
 		result = core.BNGetMediumLevelILSSAForm(self.handle)
 		if not result:
@@ -937,7 +973,7 @@ class MediumLevelILFunction(object):
 		return MediumLevelILFunction(self._arch, result, self._source_function)
 
 	@property
-	def non_ssa_form(self):
+	def non_ssa_form(self) -> Optional['MediumLevelILFunction']:
 		"""Medium level IL in non-SSA (default) form (read-only)"""
 		result = core.BNGetMediumLevelILNonSSAForm(self.handle)
 		if not result:
@@ -945,7 +981,7 @@ class MediumLevelILFunction(object):
 		return MediumLevelILFunction(self._arch, result, self._source_function)
 
 	@property
-	def low_level_il(self):
+	def low_level_il(self) -> Optional['lowlevelil.LowLevelILFunction']:
 		"""Low level IL for this function"""
 		result = core.BNGetLowLevelILForMediumLevelIL(self.handle)
 		if not result:
@@ -953,38 +989,43 @@ class MediumLevelILFunction(object):
 		return lowlevelil.LowLevelILFunction(self._arch, result, self._source_function)
 
 	@property
-	def llil(self):
+	def llil(self) -> Optional['lowlevelil.LowLevelILFunction']:
 		"""Alias for low_level_il"""
 		return self.low_level_il
 
 	@property
-	def high_level_il(self):
+	def high_level_il(self) -> Optional[highlevelil.HighLevelILFunction]:
 		"""High level IL for this medium level IL."""
 		result = core.BNGetHighLevelILForMediumLevelIL(self.handle)
 		if not result:
 			return None
-		return binaryninja.highlevelil.HighLevelILFunction(self._arch, result, self._source_function)
+		return highlevelil.HighLevelILFunction(self._arch, result, self._source_function)
 
 	@property
-	def hlil(self):
+	def hlil(self) -> Optional[highlevelil.HighLevelILFunction]:
 		return self.high_level_il
 
-	def get_instruction_start(self, addr, arch = None):
-		if arch is None:
-			arch = self._arch
-		result = core.BNMediumLevelILGetInstructionStart(self.handle, arch.handle, addr)
+	def get_instruction_start(self, addr:int, arch:Optional['architecture.Architecture']=None) -> Optional[int]:
+		_arch = arch
+		if _arch is None:
+			if self._arch is None:
+				raise Exception("Attempting to get_instruction_start from a MLIL Function without an Architecture")
+			_arch = self._arch
+		result = core.BNMediumLevelILGetInstructionStart(self.handle, _arch.handle, addr)
 		if result >= core.BNGetMediumLevelILInstructionCount(self.handle):
 			return None
 		return result
 
-	def expr(self, operation, a = 0, b = 0, c = 0, d = 0, e = 0, size = 0):
+	def expr(self, operation:MediumLevelILOperation, a:int=0, b:int=0, c:int=0, d:int=0, e:int=0,
+		size:int=0) -> MediumLevelILExpr:
+		_operation = operation
 		if isinstance(operation, str):
-			operation = MediumLevelILOperation[operation]
+			_operation = MediumLevelILOperation[operation]
 		elif isinstance(operation, MediumLevelILOperation):
-			operation = operation.value
-		return MediumLevelILExpr(core.BNMediumLevelILAddExpr(self.handle, operation, size, a, b, c, d, e))
+			_operation = operation.value
+		return MediumLevelILExpr(core.BNMediumLevelILAddExpr(self.handle, _operation, size, a, b, c, d, e))
 
-	def append(self, expr):
+	def append(self, expr:MediumLevelILExpr) -> int:
 		"""
 		``append`` adds the MediumLevelILExpr ``expr`` to the current MediumLevelILFunction.
 
@@ -994,7 +1035,7 @@ class MediumLevelILFunction(object):
 		"""
 		return core.BNMediumLevelILAddInstruction(self.handle, expr.index)
 
-	def goto(self, label):
+	def goto(self, label:MediumLevelILLabel) -> MediumLevelILExpr:
 		"""
 		``goto`` returns a goto expression which jumps to the provided MediumLevelILLabel.
 
@@ -1004,7 +1045,7 @@ class MediumLevelILFunction(object):
 		"""
 		return MediumLevelILExpr(core.BNMediumLevelILGoto(self.handle, label.handle))
 
-	def if_expr(self, operand, t, f):
+	def if_expr(self, operand:MediumLevelILExpr, t:MediumLevelILLabel, f:MediumLevelILLabel) -> MediumLevelILExpr:
 		"""
 		``if_expr`` returns the ``if`` expression which depending on condition ``operand`` jumps to the MediumLevelILLabel
 		``t`` when the condition expression ``operand`` is non-zero and ``f`` when it's zero.
@@ -1017,7 +1058,7 @@ class MediumLevelILFunction(object):
 		"""
 		return MediumLevelILExpr(core.BNMediumLevelILIf(self.handle, operand.index, t.handle, f.handle))
 
-	def mark_label(self, label):
+	def mark_label(self, label:MediumLevelILLabel) -> None:
 		"""
 		``mark_label`` assigns a MediumLevelILLabel to the current IL address.
 
@@ -1026,21 +1067,24 @@ class MediumLevelILFunction(object):
 		"""
 		core.BNMediumLevelILMarkLabel(self.handle, label.handle)
 
-	def add_label_list(self, labels):
+	def add_label_map(self, labels:Mapping[int, MediumLevelILLabel]) -> MediumLevelILExpr:
 		"""
-		``add_label_list`` returns a label list expression for the given list of MediumLevelILLabel objects.
+		``add_label_map`` returns a label list expression for the given list of MediumLevelILLabel objects.
 
 		:param labels: the list of MediumLevelILLabel to get a label list expression from
-		:type labels: list(MediumLevelILLabel)
+		:type labels: dict(int, MediumLevelILLabel)
 		:return: the label list expression
 		:rtype: MediumLevelILExpr
 		"""
-		label_list = (ctypes.POINTER(core.BNMediumLevelILLabel) * len(labels))()
-		for i in range(len(labels)):
-			label_list[i] = labels[i].handle
-		return MediumLevelILExpr(core.BNMediumLevelILAddLabelList(self.handle, label_list, len(labels)))
+		label_list = (ctypes.POINTER(core.BNMediumLevelILLabel) * len(labels))()  # type: ignore
+		value_list = (ctypes.POINTER(ctypes.c_ulonglong) * len(labels))()  # type: ignore
+		for i, (key, value) in enumerate(labels.items()):
+			value_list[i] = key
+			label_list[i] = value.handle
 
-	def add_operand_list(self, operands):
+		return MediumLevelILExpr(core.BNMediumLevelILAddLabelMap(self.handle, value_list, label_list, len(labels)))
+
+	def add_operand_list(self, operands:List[ExpressionIndex]) -> MediumLevelILExpr:
 		"""
 		``add_operand_list`` returns an operand list expression for the given list of integer operands.
 
@@ -1054,7 +1098,7 @@ class MediumLevelILFunction(object):
 			operand_list[i] = operands[i]
 		return MediumLevelILExpr(core.BNMediumLevelILAddOperandList(self.handle, operand_list, len(operands)))
 
-	def finalize(self):
+	def finalize(self) -> None:
 		"""
 		``finalize`` ends the function and computes the list of basic blocks.
 
@@ -1062,13 +1106,13 @@ class MediumLevelILFunction(object):
 		"""
 		core.BNFinalizeMediumLevelILFunction(self.handle)
 
-	def get_ssa_instruction_index(self, instr):
+	def get_ssa_instruction_index(self, instr:InstructionIndex) -> InstructionIndex:
 		return core.BNGetMediumLevelILSSAInstructionIndex(self.handle, instr)
 
-	def get_non_ssa_instruction_index(self, instr):
+	def get_non_ssa_instruction_index(self, instr:InstructionIndex) -> InstructionIndex:
 		return core.BNGetMediumLevelILNonSSAInstructionIndex(self.handle, instr)
 
-	def get_ssa_var_definition(self, ssa_var):
+	def get_ssa_var_definition(self, ssa_var:SSAVariable) -> Optional[MediumLevelILInstruction]:
 		var_data = core.BNVariable()
 		var_data.type = ssa_var.var.source_type
 		var_data.index = ssa_var.var.index
@@ -1078,35 +1122,37 @@ class MediumLevelILFunction(object):
 			return None
 		return self[result]
 
-	def get_ssa_memory_definition(self, version):
+	def get_ssa_memory_definition(self, version:int) -> Optional[MediumLevelILInstruction]:
 		result = core.BNGetMediumLevelILSSAMemoryDefinition(self.handle, version)
 		if result >= core.BNGetMediumLevelILInstructionCount(self.handle):
 			return None
 		return self[result]
 
-	def get_ssa_var_uses(self, ssa_var):
+	def get_ssa_var_uses(self, ssa_var:SSAVariable) -> List[MediumLevelILInstruction]:
 		count = ctypes.c_ulonglong()
 		var_data = core.BNVariable()
 		var_data.type = ssa_var.var.source_type
 		var_data.index = ssa_var.var.index
 		var_data.storage = ssa_var.var.storage
 		instrs = core.BNGetMediumLevelILSSAVarUses(self.handle, var_data, ssa_var.version, count)
+		assert instrs is not None, "core.BNGetMediumLevelILSSAVarUses returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(self[instrs[i]])
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def get_ssa_memory_uses(self, version):
+	def get_ssa_memory_uses(self, version:int) -> List[MediumLevelILInstruction]:
 		count = ctypes.c_ulonglong()
 		instrs = core.BNGetMediumLevelILSSAMemoryUses(self.handle, version, count)
+		assert instrs is not None, "core.BNGetMediumLevelILSSAMemoryUses returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(self[instrs[i]])
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def is_ssa_var_live(self, ssa_var):
+	def is_ssa_var_live(self, ssa_var:SSAVariable) -> bool:
 		"""
 		``is_ssa_var_live`` determines if ``ssa_var`` is live at any point in the function
 
@@ -1120,20 +1166,34 @@ class MediumLevelILFunction(object):
 		var_data.storage = ssa_var.var.storage
 		return core.BNIsMediumLevelILSSAVarLive(self.handle, var_data, ssa_var.version)
 
-	def get_var_definitions(self, var):
+	def get_var_definitions(self, var:'variable.Variable') -> List[MediumLevelILInstruction]:
+		count = ctypes.c_ulonglong()
+		var_data = core.BNVariable()
+		var_data.type = var.source_type
+		var_data.index = var.index
+		var_data.storage = var.storage
+		instrs = core.BNGetMediumLevelILVariableDefinitions(self.handle, var_data, count)
+		assert instrs is not None, "core.BNGetMediumLevelILVariableDefinitions returned None"
+		result = []
+		for i in range(0, count.value):
+			result.append(self[instrs[i]])
+		core.BNFreeILInstructionList(instrs)
+		return result
+
+	def get_var_uses(self, var:'variable.Variable') -> List[MediumLevelILInstruction]:
 		count = ctypes.c_ulonglong()
 		var_data = core.BNVariable()
 		var_data.type = var.source_type
 		var_data.index = var.index
 		var_data.storage = var.storage
 		instrs = core.BNGetMediumLevelILVariableDefinitions(self.handle, var_data, count)
+		assert instrs is not None, "core.BNGetMediumLevelILVariableDefinitions returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(self[instrs[i]])
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def get_var_uses(self, var):
 		count = ctypes.c_ulonglong()
 		var_data = core.BNVariable()
 		var_data.type = var.source_type
@@ -1146,16 +1206,16 @@ class MediumLevelILFunction(object):
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def get_ssa_var_value(self, ssa_var):
+	def get_ssa_var_value(self, ssa_var:SSAVariable) -> 'variable.RegisterValue':
 		var_data = core.BNVariable()
 		var_data.type = ssa_var.var.source_type
 		var_data.index = ssa_var.var.index
 		var_data.storage = ssa_var.var.storage
 		value = core.BNGetMediumLevelILSSAVarValue(self.handle, var_data, ssa_var.version)
-		result = function.RegisterValue(self._arch, value)
+		result = variable.RegisterValue(self._arch, value)
 		return result
 
-	def get_low_level_il_instruction_index(self, instr):
+	def get_low_level_il_instruction_index(self, instr:InstructionIndex) -> Optional['lowlevelil.InstructionIndex']:
 		low_il = self.low_level_il
 		if low_il is None:
 			return None
@@ -1167,7 +1227,7 @@ class MediumLevelILFunction(object):
 			return None
 		return result
 
-	def get_low_level_il_expr_index(self, expr):
+	def get_low_level_il_expr_index(self, expr:ExpressionIndex) -> Optional['lowlevelil.ExpressionIndex']:
 		low_il = self.low_level_il
 		if low_il is None:
 			return None
@@ -1179,16 +1239,17 @@ class MediumLevelILFunction(object):
 			return None
 		return result
 
-	def get_low_level_il_expr_indexes(self, expr):
+	def get_low_level_il_expr_indexes(self, expr:ExpressionIndex) -> List['lowlevelil.ExpressionIndex']:
 		count = ctypes.c_ulonglong()
 		exprs = core.BNGetLowLevelILExprIndexes(self.handle, expr, count)
+		assert exprs is not None, "core.BNGetLowLevelILExprIndexes returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(exprs[i])
 		core.BNFreeILInstructionList(exprs)
 		return result
 
-	def get_high_level_il_instruction_index(self, instr):
+	def get_high_level_il_instruction_index(self, instr:InstructionIndex) -> Optional['highlevelil.InstructionIndex']:
 		high_il = self.high_level_il
 		if high_il is None:
 			return None
@@ -1197,7 +1258,7 @@ class MediumLevelILFunction(object):
 			return None
 		return result
 
-	def get_high_level_il_expr_index(self, expr):
+	def get_high_level_il_expr_index(self, expr:ExpressionIndex) -> Optional['highlevelil.ExpressionIndex']:
 		high_il = self.high_level_il
 		if high_il is None:
 			return None
@@ -1206,90 +1267,36 @@ class MediumLevelILFunction(object):
 			return None
 		return result
 
-	def get_high_level_il_expr_indexes(self, expr):
+	def get_high_level_il_expr_indexes(self, expr:ExpressionIndex) -> List['highlevelil.ExpressionIndex']:
 		count = ctypes.c_ulonglong()
 		exprs = core.BNGetHighLevelILExprIndexes(self.handle, expr, count)
+		assert exprs is not None, "core.BNGetHighLevelILExprIndexes returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(exprs[i])
 		core.BNFreeILInstructionList(exprs)
 		return result
 
-	def create_graph(self, settings = None):
+	def create_graph(self, settings:'function.DisassemblySettings'=None) -> flowgraph.CoreFlowGraph:
 		if settings is not None:
 			settings_obj = settings.handle
 		else:
 			settings_obj = None
-		return binaryninja.flowgraph.CoreFlowGraph(core.BNCreateMediumLevelILFunctionGraph(self.handle, settings_obj))
+		return flowgraph.CoreFlowGraph(core.BNCreateMediumLevelILFunctionGraph(self.handle, settings_obj))
 
 	@property
-	def arch(self):
-		""" """
+	def arch(self) -> 'architecture.Architecture':
 		return self._arch
 
-	@arch.setter
-	def arch(self, value):
-		self._arch = value
-
 	@property
-	def source_function(self):
-		""" """
+	def source_function(self) -> 'function.Function':
 		return self._source_function
 
-	@source_function.setter
-	def source_function(self, value):
-		self._source_function = value
-
-	@property
-	def il_form(self) -> "binaryninja.enums.FunctionGraphType":
-		if len(self.basic_blocks) < 1:
-			return FunctionGraphType.InvalidILViewType
-		return FunctionGraphType(core.BNGetBasicBlockFunctionGraphType(self.basic_blocks[0].handle))
-
-	@property
-	def vars(self) -> List["binaryninja.function.Variable"]:
-		"""This gets just the MLIL variables - you may be interested in the union of `MediumLevelIlFunction.source_function.param_vars` for all the variables used in the function"""
-		if self.source_function is None:
-			return []
-
-		if self.il_form in [FunctionGraphType.MediumLevelILFunctionGraph, FunctionGraphType.MediumLevelILSSAFormFunctionGraph, FunctionGraphType.MappedMediumLevelILFunctionGraph, FunctionGraphType.MappedMediumLevelILSSAFormFunctionGraph]:
-			count = ctypes.c_ulonglong()
-			core_variables = core.BNGetMediumLevelILVariables(self.handle, count)
-			result = []
-			for var_i in range(count.value):
-				result.append(function.Variable(self.source_function, core_variables[var_i].type, core_variables[var_i].index, core_variables[var_i].storage))
-			core.BNFreeVariableList(core_variables)
-			return result
-		return []
-
-	@property
-	def ssa_vars(self) -> List["binaryninja.mediumlevelil.SSAVariable"]:
-		"""This gets just the MLIL SSA variables - you may be interested in the union of `MediumLevelIlFunction.source_function.param_vars` for all the variables used in the function"""
-		if self.source_function is None:
-			return []
-
-		if self.il_form in [FunctionGraphType.MediumLevelILSSAFormFunctionGraph, FunctionGraphType.MappedMediumLevelILSSAFormFunctionGraph]:
-			variable_count = ctypes.c_ulonglong()
-			core_variables = core.BNGetMediumLevelILVariables(self.handle, variable_count)
-			result = []
-			for var_i in range(variable_count.value):
-				version_count = ctypes.c_ulonglong()
-				versions = core.BNGetMediumLevelILVariableSSAVersions(self.handle, core_variables[var_i], version_count)
-
-				for version_i in range(version_count.value):
-					result.append(SSAVariable(function.Variable(self.source_function, core_variables[var_i].type, core_variables[var_i].index, core_variables[var_i].storage), versions[version_i]))
-				core.BNFreeILInstructionList(versions)
-
-			core.BNFreeVariableList(core_variables)
-			return result
-
-		return []
-
 
 class MediumLevelILBasicBlock(basicblock.BasicBlock):
-	def __init__(self, view, handle, owner):
+	def __init__(self, handle:core.BNBasicBlock, owner:MediumLevelILFunction, view:Optional['binaryview.BinaryView']=None):
 		super(MediumLevelILBasicBlock, self).__init__(handle, view)
-		self.il_function = owner
+		self._il_function = owner
 
 	def __repr__(self):
 		arch = self.arch
@@ -1300,7 +1307,7 @@ class MediumLevelILBasicBlock(basicblock.BasicBlock):
 
 	def __iter__(self):
 		for idx in range(self.start, self.end):
-			yield self.il_function[idx]
+			yield self._il_function[idx]
 
 	def __getitem__(self, idx):
 		size = self.end - self.start
@@ -1309,12 +1316,12 @@ class MediumLevelILBasicBlock(basicblock.BasicBlock):
 		if idx > size or idx < -size:
 			raise IndexError("list index is out of range")
 		if idx >= 0:
-			return self.il_function[idx + self.start]
+			return self._il_function[idx + self.start]
 		else:
-			return self.il_function[self.end + idx]
+			return self._il_function[self.end + idx]
 
 	def __hash__(self):
-		return hash((self.start, self.end, self.il_function))
+		return hash((self.start, self.end, self._il_function))
 
 	def __contains__(self, instruction):
 		if type(instruction) != MediumLevelILInstruction or instruction.il_basic_block != self:
@@ -1324,15 +1331,14 @@ class MediumLevelILBasicBlock(basicblock.BasicBlock):
 		else:
 			return False
 
-	def _create_instance(self, handle, view):
+	def _create_instance(self, handle:core.BNBasicBlock, view:'binaryview.BinaryView') -> 'MediumLevelILBasicBlock':
 		"""Internal method by super to instantiate child instances"""
-		return MediumLevelILBasicBlock(view, handle, self.il_function)
+		return MediumLevelILBasicBlock(handle, self.il_function, view)
 
 	@property
-	def il_function(self):
-		""" """
-		return self._il_function
+	def instruction_count(self) -> int:
+		return self.end - self.start
 
-	@il_function.setter
-	def il_function(self, value):
-		self._il_function = value
+	@property
+	def il_function(self) -> 'MediumLevelILFunction':
+		return self._il_function