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

1 files changed, 235 insertions, 194 deletions

diff --git a/python/highlevelil.py b/python/highlevelil.py
index 45f6def4..71c58920 100644
--- a/python/highlevelil.py
+++ b/python/highlevelil.py
@@ -20,21 +20,28 @@
 
 import ctypes
 import struct
-from typing import List
+from typing import Optional, Generator, List, Union, Any, NewType
 
 # Binary Ninja components
-import binaryninja
-from binaryninja import _binaryninjacore as core
-from binaryninja.enums import HighLevelILOperation, FunctionGraphType
-from binaryninja import function
-from binaryninja import lowlevelil
-from binaryninja import mediumlevelil
-from binaryninja import basicblock
-from binaryninja import types
-
-# 2-3 compatibility
-from binaryninja import range
+from . import _binaryninjacore as core
+from .enums import HighLevelILOperation, InstructionTextTokenType, DataFlowQueryOption, FunctionGraphType
+from .variable import Variable
+from . import function
+from . import binaryview
+from . import architecture
+from . import lowlevelil
+from . import mediumlevelil
+from . import basicblock
+from . import types
+from . import highlight
+from . import flowgraph
+from . import variable
 
+LinesType = Generator['function.DisassemblyTextLine', None, None]
+ExpressionIndex = NewType('ExpressionIndex', int)
+InstructionIndex = NewType('InstructionIndex', int)
+HLILInstructionsType = Generator['HighLevelILInstruction', None, None]
+HLILBasicBlocksType = Generator['HighLevelILBasicBlock', None, None]
 
 class HighLevelILOperationAndSize(object):
 	def __init__(self, operation, size):
@@ -63,7 +70,6 @@ class HighLevelILOperationAndSize(object):
 
 	@property
 	def operation(self):
-		""" """
 		return self._operation
 
 	@operation.setter
@@ -72,7 +78,6 @@ class HighLevelILOperationAndSize(object):
 
 	@property
 	def size(self):
-		""" """
 		return self._size
 
 	@size.setter
@@ -241,9 +246,12 @@ class HighLevelILInstruction(object):
 		HighLevelILOperation.HLIL_FCMP_UO: [("left", "expr"), ("right", "expr")]
 	}
 
-	def __init__(self, func, expr_index, as_ast = True, instr_index = None):
+	def __init__(self, func:'HighLevelILFunction', expr_index:ExpressionIndex, as_ast:bool = True,
+		instr_index:InstructionIndex = None):
 		instr = core.BNGetHighLevelILByIndex(func.handle, expr_index, as_ast)
 		self._function = func
+		if func.arch is None:
+			raise Exception("HighLevelILFunction architecture must not be None")
 		self._expr_index = expr_index
 		if instr_index is None:
 			self._instr_index = core.BNGetHighLevelILInstructionForExpr(func.handle, expr_index)
@@ -260,6 +268,7 @@ class HighLevelILInstruction(object):
 		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))
@@ -275,15 +284,16 @@ class HighLevelILInstruction(object):
 			elif operand_type == "intrinsic":
 				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 = mediumlevelil.SSAVariable(var, version)
 			elif operand_type == "int_list":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNHighLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNHighLevelILGetOperandList returned None"
 				value = []
 				for j in range(count.value):
 					value.append(operand_list[j])
@@ -291,6 +301,7 @@ class HighLevelILInstruction(object):
 			elif operand_type == "expr_list":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNHighLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNHighLevelILGetOperandList returned None"
 				i += 1
 				value = []
 				for j in range(count.value):
@@ -299,12 +310,13 @@ class HighLevelILInstruction(object):
 			elif operand_type == "var_ssa_list":
 				count = ctypes.c_ulonglong()
 				operand_list = core.BNHighLevelILGetOperandList(func.handle, self._expr_index, i, count)
+				assert operand_list is not None, "core.BNHighLevelILGetOperandList 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(mediumlevelil.SSAVariable(function.Variable.from_identifier(self._function.source_function,
+					value.append(mediumlevelil.SSAVariable(variable.Variable.from_identifier(self._function.source_function,
 						var_id), var_version))
 				core.BNHighLevelILFreeOperandList(operand_list)
 			elif operand_type == "member_index":
@@ -336,9 +348,9 @@ class HighLevelILInstruction(object):
 			first_line = "<invalid>"
 		else:
 			first_line = ""
-			for token in lines[0].tokens:
+			for token in next(lines).tokens:
 				first_line += token.text
-			if len(lines) > 1:
+			if len(list(lines)) > 1:
 				continuation = "..."
 		return "<%s: %s%s>" % (self._operation.name, first_line, continuation)
 
@@ -376,25 +388,26 @@ class HighLevelILInstruction(object):
 		return hash((self._function, self._expr_index))
 
 	@property
-	def lines(self):
+	def lines(self) -> LinesType:
 		"""HLIL text lines (read-only)"""
 		count = ctypes.c_ulonglong()
 		lines = core.BNGetHighLevelILExprText(self._function.handle, self._expr_index, self._as_ast, count, None)
-		result = []
-		for i in range(0, count.value):
-			addr = lines[i].addr
-			if lines[i].instrIndex != 0xffffffffffffffff:
-				il_instr = self._function[lines[i].instrIndex]
-			else:
-				il_instr = None
-			color = binaryninja.highlight.HighlightColor._from_core_struct(lines[i].highlight)
-			tokens = binaryninja.function.InstructionTextToken.get_instruction_lines(lines[i].tokens, lines[i].count)
-			result.append(binaryninja.function.DisassemblyTextLine(tokens, addr, il_instr, color))
-		core.BNFreeDisassemblyTextLines(lines, count.value)
-		return result
+		assert lines is not None, "core.BNGetHighLevelILExprText returned None"
+		try:
+			for i in range(0, count.value):
+				addr = lines[i].addr
+				if lines[i].instrIndex != 0xffffffffffffffff:
+					il_instr = self._function[lines[i].instrIndex]
+				else:
+					il_instr = None
+				color = highlight.HighlightColor._from_core_struct(lines[i].highlight)
+				tokens = function.InstructionTextToken._from_core_struct(lines[i].tokens, lines[i].count)
+				yield function.DisassemblyTextLine(tokens, addr, il_instr, color)
+		finally:
+			core.BNFreeDisassemblyTextLines(lines, count.value)
 
 	@property
-	def prefix_operands(self):
+	def prefix_operands(self) -> List[Any]:
 		"""All operands in the expression tree in prefix order"""
 		result = [HighLevelILOperationAndSize(self._operation, self._size)]
 		for operand in self._operands:
@@ -405,7 +418,7 @@ class HighLevelILInstruction(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:
@@ -417,141 +430,144 @@ class HighLevelILInstruction(object):
 		return result
 
 	@property
-	def function(self):
-		""" """
+	def function(self) -> 'HighLevelILFunction':
 		return self._function
 
 	@property
-	def expr_index(self):
-		""" """
+	def expr_index(self) -> ExpressionIndex:
 		return self._expr_index
 
 	@expr_index.setter
-	def expr_index(self, value):
+	def expr_index(self, value:ExpressionIndex) -> None:
 		self._expr_index = value
 
 	@property
-	def instr_index(self):
+	def instr_index(self) -> int:
 		"""Index of the statement that this expression belongs to (read-only)"""
 		return core.BNGetHighLevelILInstructionForExpr(self._function.handle, self._expr_index)
 
 	@property
-	def instr(self):
+	def instr(self) -> 'HighLevelILInstruction':
 		"""The statement that this expression belongs to (read-only)"""
 		return self._function[self.instr_index]
 
 	@property
-	def ast(self):
+	def ast(self) -> 'HighLevelILInstruction':
 		"""This expression with full AST printing (read-only)"""
 		if self._as_ast:
 			return self
 		return HighLevelILInstruction(self._function, self._expr_index, True)
 
 	@property
-	def non_ast(self):
+	def non_ast(self) -> 'HighLevelILInstruction':
 		"""This expression without full AST printing (read-only)"""
 		if not self._as_ast:
 			return self
 		return HighLevelILInstruction(self._function, self._expr_index, False)
 
 	@property
-	def operation(self):
-		""" """
+	def operation(self) -> HighLevelILOperation:
 		return self._operation
 
 	@operation.setter
-	def operation(self, value):
+	def operation(self, value:HighLevelILOperation) -> None:
 		self._operation = value
 
 	@property
-	def size(self):
-		""" """
+	def size(self) -> int:
 		return self._size
 
 	@size.setter
-	def size(self, value):
+	def size(self, value:int) -> None:
 		self._size = value
 
 	@property
-	def address(self):
-		""" """
+	def address(self) -> int:
 		return self._address
 
 	@address.setter
-	def address(self, value):
+	def address(self, value:int) -> None:
 		self._address = value
 
 	@property
 	def source_operand(self):
-		""" """
-		return self._source_operand
+				return self._source_operand
 
 	@source_operand.setter
 	def source_operand(self, value):
 		self._source_operand = value
 
 	@property
-	def operands(self):
-		""" """
+	def operands(self) -> Any:
 		return self._operands
 
 	@operands.setter
-	def operands(self, value):
+	def operands(self, value: Any):
 		self._operands = value
 
 	@property
-	def parent(self):
+	def parent(self) -> Optional['HighLevelILInstruction']:
 		if self._parent >= core.BNGetHighLevelILExprCount(self._function.handle):
 			return None
 		return HighLevelILInstruction(self._function, self._parent, self._as_ast)
 
 	@property
-	def ssa_form(self):
+	def ssa_form(self) -> 'HighLevelILInstruction':
 		"""SSA form of expression (read-only)"""
+		assert self._function.ssa_form is not None
 		return HighLevelILInstruction(self._function.ssa_form,
 			core.BNGetHighLevelILSSAExprIndex(self._function.handle, self._expr_index), self._as_ast)
 
 	@property
-	def non_ssa_form(self):
+	def non_ssa_form(self) -> Optional['HighLevelILInstruction']:
 		"""Non-SSA form of expression (read-only)"""
+		if self._function.non_ssa_form is None:
+			return None
 		return HighLevelILInstruction(self._function.non_ssa_form,
 			core.BNGetHighLevelILNonSSAExprIndex(self._function.handle, self._expr_index), self._as_ast)
 
 	@property
-	def medium_level_il(self):
+	def medium_level_il(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
 		"""Medium level IL form of this expression"""
 		expr = self._function.get_medium_level_il_expr_index(self._expr_index)
 		if expr is None:
 			return None
-		return mediumlevelil.MediumLevelILInstruction(self._function.medium_level_il.ssa_form, expr)
+		mlil = self._function.medium_level_il
+		if mlil is None:
+			return None
+		ssa_func = mlil.ssa_form
+		assert ssa_func is not None, "medium_level_il.ssa_form is None"
+		return mediumlevelil.MediumLevelILInstruction(ssa_func, expr)
 
 	@property
-	def mlil(self):
+	def mlil(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
 		"""Alias for medium_level_il"""
 		return self.medium_level_il
 
 	@property
-	def mlils(self):
-		exprs = self._function.get_medium_level_il_expr_indexes(self._expr_index)
-		result = []
-		for expr in exprs:
-			result.append(mediumlevelil.MediumLevelILInstruction(self._function.medium_level_il.ssa_form, expr))
-		return result
+	def mlils(self) -> Generator['mediumlevelil.MediumLevelILInstruction', None, None]:
+		for expr in self._function.get_medium_level_il_expr_indexes(self._expr_index):
+			mlil = self._function.medium_level_il
+			if mlil is None:
+				return
+			ssa_func = mlil.ssa_form
+			assert ssa_func is not None, "medium_level_il.ssa_form is None"
+			yield mediumlevelil.MediumLevelILInstruction(ssa_func, expr)
 
 	@property
-	def low_level_il(self):
+	def low_level_il(self) -> Optional['lowlevelil.LowLevelILInstruction']:
 		"""Low level IL form of this expression"""
 		if self.mlil is None:
 			return None
 		return self.mlil.llil
 
 	@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.LowLevelILExpr']:
 		result = set()
 		for mlil_expr in self.mlils:
 			for llil_expr in mlil_expr.llils:
@@ -559,34 +575,34 @@ class HighLevelILInstruction(object):
 		return list(result)
 
 	@property
-	def il_basic_block(self):
+	def il_basic_block(self) -> Optional['HighLevelILBasicBlock']:
 		"""
 		IL basic block object containing this expression (read-only) (only available on finalized functions).
 		Returns None for HLIL_BLOCK expressions as these can contain multiple basic blocks.
 		"""
 		block = core.BNGetHighLevelILBasicBlockForInstruction(self._function.handle, self._instr_index)
-		if not block:
+		if not block or self._function.source_function is None:
 			return None
 		return HighLevelILBasicBlock(self._function.source_function.view, block, self._function)
 
 	@property
-	def value(self):
+	def value(self) -> 'variable.RegisterValue':
 		"""Value of expression if constant or a known value (read-only)"""
 		mlil = self.mlil
 		if mlil is None:
-			return function.RegisterValue()
+			return variable.RegisterValue()
 		return mlil.value
 
 	@property
-	def possible_values(self):
+	def possible_values(self) -> 'variable.PossibleValueSet':
 		"""Possible values of expression using path-sensitive static data flow analysis (read-only)"""
 		mlil = self.mlil
 		if mlil is None:
-			return function.PossibleValueSet()
+			return variable.PossibleValueSet()
 		return mlil.possible_values
 
 	@property
-	def expr_type(self):
+	def expr_type(self) -> Optional['types.Type']:
 		"""Type of expression"""
 		result = core.BNGetHighLevelILExprType(self._function.handle, self._expr_index)
 		if result.type:
@@ -596,18 +612,18 @@ class HighLevelILInstruction(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':
 		mlil = self.mlil
 		if mlil is None:
-			return function.RegisterValue()
+			return variable.PossibleValueSet()
 		return mlil.get_possible_values(options)
 
 	@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.BNGetHighLevelILSSAMemoryVersionAtILInstruction(self._function.handle, self._instr_index)
 
-	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
@@ -622,31 +638,28 @@ class HighLevelILExpr(object):
 	.. note:: This class shouldn't be instantiated directly. Rather the helper members of HighLevelILFunction should be \
 	used instead.
 	"""
-	def __init__(self, index):
+	def __init__(self, index:ExpressionIndex):
 		self._index = index
 
 	@property
-	def index(self):
-		""" """
+	def index(self) -> ExpressionIndex:
 		return self._index
 
-	@index.setter
-	def index(self, value):
-		self._index = value
 
 
 class HighLevelILFunction(object):
 	"""
 	``class HighLevelILFunction`` contains the a HighLevelILInstruction object that makes up the abstract syntax tree of
-	a binaryninja.function.
+	a function.
 	"""
-	def __init__(self, arch = None, handle = None, source_func = None):
+	def __init__(self, arch:Optional['architecture.Architecture']=None, handle:core.BNHighLevelILFunction=None,
+		source_func:'function.Function'=None):
 		self._arch = arch
 		self._source_function = source_func
 		if handle is not None:
 			self.handle = core.handle_of_type(handle, core.BNHighLevelILFunction)
 			if self._source_function is None:
-				self._source_function = binaryninja.function.Function(handle = core.BNGetHighLevelILOwnerFunction(self.handle))
+				self._source_function = function.Function(handle = core.BNGetHighLevelILOwnerFunction(self.handle))
 			if self._arch is None:
 				self._arch = self._source_function.arch
 		else:
@@ -655,8 +668,12 @@ class HighLevelILFunction(object):
 				raise ValueError("IL functions must be created with an associated function")
 			if self._arch is None:
 				self._arch = self._source_function.arch
+				if self._arch is None:
+					raise ValueError("IL functions must be created with an associated Architecture")
 			func_handle = self._source_function.handle
-			self.handle = core.BNCreateHighLevelILFunction(arch.handle, func_handle)
+			self.handle = core.BNCreateHighLevelILFunction(self._arch.handle, func_handle)
+		assert self._source_function is not None
+		assert self._arch is not None
 
 	def __del__(self):
 		if self.handle is not None:
@@ -672,6 +689,8 @@ class HighLevelILFunction(object):
 	def __eq__(self, other):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
+		assert self.handle is not None
+		assert other.handle is not None
 		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
 
 	def __ne__(self, other):
@@ -682,22 +701,61 @@ class HighLevelILFunction(object):
 	def __hash__(self):
 		return hash(('HLIL', self._source_function))
 
+	def __len__(self):
+		return int(core.BNGetHighLevelILInstructionCount(self.handle))
+
+	def __getitem__(self, i:Union[HighLevelILExpr, HighLevelILInstruction, int]) -> HighLevelILInstruction:
+		if isinstance(i, slice) or isinstance(i, tuple):
+			raise IndexError("expected integer instruction index")
+		if isinstance(i, HighLevelILExpr):
+			return HighLevelILInstruction(self, i.index)
+		# for backwards compatibility
+		if isinstance(i, HighLevelILInstruction):
+			return i
+		if i < -len(self) or i >= len(self):
+			raise IndexError("index out of range")
+		if i < 0:
+			i = len(self) + i
+		return HighLevelILInstruction(self, core.BNGetHighLevelILIndexForInstruction(self.handle, i), False,
+			InstructionIndex(i))
+
+	def __setitem__(self, i, j):
+		raise IndexError("instruction modification not implemented")
+
+	def __iter__(self) -> Generator['HighLevelILBasicBlock', None, None]:
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetHighLevelILBasicBlockList(self.handle, count)
+		assert blocks is not None, "core.BNGetHighLevelILBasicBlockList returned None"
+		view = None
+		if self._source_function is not None:
+			view = self._source_function.view
+		try:
+			for i in range(0, count.value):
+				core_block = core.BNNewBasicBlockReference(blocks[i])
+				assert core_block is not None
+				yield HighLevelILBasicBlock(view, core_block, self)
+		finally:
+			core.BNFreeBasicBlockList(blocks, count.value)
+
+	def __str__(self) -> str:
+		return str(self.root)
+
 	@property
-	def current_address(self):
+	def current_address(self) -> int:
 		"""Current IL Address (read/write)"""
 		return core.BNHighLevelILGetCurrentAddress(self.handle)
 
 	@current_address.setter
-	def current_address(self, value):
-		core.BNHighLevelILSetCurrentAddress(self.handle, self._arch.handle, value)
+	def current_address(self, value:int) -> None:
+		core.BNHighLevelILSetCurrentAddress(self.handle, self.arch.handle, value)
 
-	def set_current_address(self, value, arch = None):
+	def set_current_address(self, value:int, arch:Optional['architecture.Architecture'] = None) -> None:
 		if arch is None:
-			arch = self._arch
+			arch = self.arch
 		core.BNHighLevelILSetCurrentAddress(self.handle, arch.handle, value)
 
 	@property
-	def root(self):
+	def root(self) -> Optional[HighLevelILInstruction]:
 		"""Root of the abstract syntax tree"""
 		expr_index = core.BNGetHighLevelILRootExpr(self.handle)
 		if expr_index >= core.BNGetHighLevelILExprCount(self.handle):
@@ -705,53 +763,80 @@ class HighLevelILFunction(object):
 		return HighLevelILInstruction(self, expr_index)
 
 	@root.setter
-	def root(self, value):
+	def root(self, value:HighLevelILInstruction) -> None:
 		core.BNSetHighLevelILRootExpr(value.expr_index)
 
 	@property
-	def basic_blocks(self):
+	def basic_blocks(self) -> Generator['HighLevelILBasicBlock', None, None]:
 		"""list of HighLevelILBasicBlock objects (read-only)"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetHighLevelILBasicBlockList(self.handle, count)
-		result = []
+		assert blocks is not None, "core.BNGetHighLevelILBasicBlockList 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(HighLevelILBasicBlock(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 HighLevelILBasicBlock(view, core_block, self)
+		finally:
+			core.BNFreeBasicBlockList(blocks, count.value)
 
 	@property
-	def instructions(self):
+	def instructions(self) -> Generator[HighLevelILInstruction, None, None]:
 		"""A generator of hlil 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) -> 'HighLevelILFunction':
 		"""High level IL in SSA form (read-only)"""
 		result = core.BNGetHighLevelILSSAForm(self.handle)
-		if not result:
-			return None
+		assert result is not None
 		return HighLevelILFunction(self._arch, result, self._source_function)
 
 	@property
-	def non_ssa_form(self):
+	def non_ssa_form(self) -> Optional['HighLevelILFunction']:
 		"""High level IL in non-SSA (default) form (read-only)"""
 		result = core.BNGetHighLevelILNonSSAForm(self.handle)
 		if not result:
 			return None
 		return HighLevelILFunction(self._arch, result, self._source_function)
 
-	def get_ssa_instruction_index(self, instr):
+	@property
+	def arch(self) -> 'architecture.Architecture':
+		assert self._arch is not None
+		return self._arch
+
+	@property
+	def source_function(self) -> 'function.Function':
+		assert self._source_function is not None
+		return self._source_function
+
+	@property
+	def medium_level_il(self) -> Optional['mediumlevelil.MediumLevelILFunction']:
+		"""Medium level IL for this function"""
+		result = core.BNGetMediumLevelILForHighLevelILFunction(self.handle)
+		if not result:
+			return None
+		return mediumlevelil.MediumLevelILFunction(self._arch, result, self._source_function)
+
+	@property
+	def mlil(self) -> Optional['mediumlevelil.MediumLevelILFunction']:
+		"""Alias for medium_level_il"""
+		return self.medium_level_il
+
+	def get_ssa_instruction_index(self, instr:int) -> int:
 		return core.BNGetHighLevelILSSAInstructionIndex(self.handle, instr)
 
-	def get_non_ssa_instruction_index(self, instr):
+	def get_non_ssa_instruction_index(self, instr:int) -> int:
 		return core.BNGetHighLevelILNonSSAInstructionIndex(self.handle, instr)
 
-	def get_ssa_var_definition(self, ssa_var):
+	def get_ssa_var_definition(self, ssa_var:'mediumlevelil.SSAVariable') -> Optional[HighLevelILInstruction]:
 		var_data = core.BNVariable()
 		var_data.type = ssa_var.var.source_type
 		var_data.index = ssa_var.var.index
@@ -761,35 +846,37 @@ class HighLevelILFunction(object):
 			return None
 		return HighLevelILInstruction(self, result)
 
-	def get_ssa_memory_definition(self, version):
+	def get_ssa_memory_definition(self, version:int) -> Optional[HighLevelILInstruction]:
 		result = core.BNGetHighLevelILSSAMemoryDefinition(self.handle, version)
 		if result >= core.BNGetHighLevelILExprCount(self.handle):
 			return None
 		return HighLevelILInstruction(self, result)
 
-	def get_ssa_var_uses(self, ssa_var):
+	def get_ssa_var_uses(self, ssa_var:'mediumlevelil.SSAVariable') -> List[HighLevelILInstruction]:
 		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.BNGetHighLevelILSSAVarUses(self.handle, var_data, ssa_var.version, count)
+		assert instrs is not None, "core.BNGetHighLevelILSSAVarUses returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(HighLevelILInstruction(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def get_ssa_memory_uses(self, version):
+	def get_ssa_memory_uses(self, version:int) -> List[HighLevelILInstruction]:
 		count = ctypes.c_ulonglong()
 		instrs = core.BNGetHighLevelILSSAMemoryUses(self.handle, version, count)
+		assert instrs is not None, "core.BNGetHighLevelILSSAMemoryUses returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(HighLevelILInstruction(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def is_ssa_var_live(self, ssa_var):
+	def is_ssa_var_live(self, ssa_var:'mediumlevelil.SSAVariable') -> bool:
 		"""
 		``is_ssa_var_live`` determines if ``ssa_var`` is live at any point in the function
 
@@ -803,81 +890,43 @@ class HighLevelILFunction(object):
 		var_data.storage = ssa_var.var.storage
 		return core.BNIsHighLevelILSSAVarLive(self.handle, var_data, ssa_var.version)
 
-	def get_var_definitions(self, var):
+	def get_var_definitions(self, var:'variable.Variable') -> List[HighLevelILInstruction]:
 		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.BNGetHighLevelILVariableDefinitions(self.handle, var_data, count)
+		assert instrs is not None, "core.BNGetHighLevelILVariableDefinitions returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(HighLevelILInstruction(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def get_var_uses(self, var):
+	def get_var_uses(self, var:'variable.Variable') -> List[HighLevelILInstruction]:
 		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.BNGetHighLevelILVariableUses(self.handle, var_data, count)
+		assert instrs is not None, "core.BNGetHighLevelILVariableUses returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(HighLevelILInstruction(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
-	def __setattr__(self, name, value):
-		try:
-			object.__setattr__(self, name, value)
-		except AttributeError:
-			raise AttributeError("attribute '%s' is read only" % name)
-
-	def __len__(self):
-		return int(core.BNGetHighLevelILInstructionCount(self.handle))
-
-	def __getitem__(self, i):
-		if isinstance(i, slice) or isinstance(i, tuple):
-			raise IndexError("expected integer instruction index")
-		if isinstance(i, HighLevelILExpr):
-			return HighLevelILInstruction(self, i.index)
-		# for backwards compatibility
-		if isinstance(i, HighLevelILInstruction):
-			return i
-		if i < -len(self) or i >= len(self):
-			raise IndexError("index out of range")
-		if i < 0:
-			i = len(self) + i
-		return HighLevelILInstruction(self, core.BNGetHighLevelILIndexForInstruction(self.handle, i), False, i)
-
-	def __setitem__(self, i, j):
-		raise IndexError("instruction modification not implemented")
-
-	def __iter__(self):
-		count = ctypes.c_ulonglong()
-		blocks = core.BNGetHighLevelILBasicBlockList(self.handle, count)
-		view = None
-		if self._source_function is not None:
-			view = self._source_function.view
-		try:
-			for i in range(0, count.value):
-				yield HighLevelILBasicBlock(view, core.BNNewBasicBlockReference(blocks[i]), self)
-		finally:
-			core.BNFreeBasicBlockList(blocks, count.value)
-
-	def __str__(self):
-		return str(self.root)
-
-	def expr(self, operation, a = 0, b = 0, c = 0, d = 0, e = 0, size = 0):
+	def expr(self, operation:Union[str, HighLevelILOperation], a:int = 0, b:int = 0, c:int = 0,
+		d:int = 0, e:int = 0, size:int = 0) -> HighLevelILExpr:
 		if isinstance(operation, str):
-			operation = HighLevelILOperation[operation]
+			operation_value = HighLevelILOperation[operation]
 		elif isinstance(operation, HighLevelILOperation):
-			operation = operation.value
-		return HighLevelILExpr(core.BNHighLevelILAddExpr(self.handle, operation, size, a, b, c, d, e))
+			operation_value = operation.value
+		return HighLevelILExpr(core.BNHighLevelILAddExpr(self.handle, operation_value, size, a, b, c, d, e))
 
-	def add_operand_list(self, operands):
+	def add_operand_list(self, operands:List[int]) -> HighLevelILExpr:
 		"""
 		``add_operand_list`` returns an operand list expression for the given list of integer operands.
 
@@ -890,7 +939,7 @@ class HighLevelILFunction(object):
 			operand_list[i] = operands[i]
 		return HighLevelILExpr(core.BNHighLevelILAddOperandList(self.handle, operand_list, len(operands)))
 
-	def finalize(self):
+	def finalize(self) -> None:
 		"""
 		``finalize`` ends the function and computes the list of basic blocks.
 
@@ -898,21 +947,12 @@ class HighLevelILFunction(object):
 		"""
 		core.BNFinalizeHighLevelILFunction(self.handle)
 
-	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.BNCreateHighLevelILFunctionGraph(self.handle, settings_obj))
-
-	@property
-	def arch(self):
-		""" """
-		return self._arch
-
-	@arch.setter
-	def arch(self, value):
-		self._arch = value
+		return flowgraph.CoreFlowGraph(core.BNCreateHighLevelILFunctionGraph(self.handle, settings_obj))
 
 	@property
 	def source_function(self):
@@ -981,7 +1021,7 @@ class HighLevelILFunction(object):
 		"""Alias for medium_level_il"""
 		return self.medium_level_il
 
-	def get_medium_level_il_expr_index(self, expr):
+	def get_medium_level_il_expr_index(self, expr:ExpressionIndex) -> Optional['mediumlevelil.ExpressionIndex']:
 		medium_il = self.medium_level_il
 		if medium_il is None:
 			return None
@@ -993,24 +1033,26 @@ class HighLevelILFunction(object):
 			return None
 		return result
 
-	def get_medium_level_il_expr_indexes(self, expr):
+	def get_medium_level_il_expr_indexes(self, expr:ExpressionIndex) -> List['mediumlevelil.ExpressionIndex']:
 		count = ctypes.c_ulonglong()
 		exprs = core.BNGetMediumLevelILExprIndexesFromHighLevelIL(self.handle, expr, count)
+		assert exprs is not None, "core.BNGetMediumLevelILExprIndexesFromHighLevelIL returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(exprs[i])
 		core.BNFreeILInstructionList(exprs)
 		return result
 
-	def get_label(self, label_idx):
+	def get_label(self, label_idx:int) -> Optional[HighLevelILInstruction]:
 		result = core.BNGetHighLevelILExprIndexForLabel(self.handle, label_idx)
 		if result >= core.BNGetHighLevelILExprCount(self.handle):
 			return None
 		return HighLevelILInstruction(self, result)
 
-	def get_label_uses(self, label_idx):
+	def get_label_uses(self, label_idx:int) -> List[HighLevelILInstruction]:
 		count = ctypes.c_ulonglong()
 		uses = core.BNGetHighLevelILUsesForLabel(self.handle, label_idx, count)
+		assert uses is not None, "core.BNGetHighLevelILUsesForLabel returned None"
 		result = []
 		for i in range(0, count.value):
 			result.append(HighLevelILInstruction(self, uses[i]))
@@ -1019,15 +1061,15 @@ class HighLevelILFunction(object):
 
 
 class HighLevelILBasicBlock(basicblock.BasicBlock):
-	def __init__(self, view, handle, owner):
+	def __init__(self, view:Optional['binaryview.BinaryView'], handle:core.BNBasicBlock, owner:HighLevelILFunction):
 		super(HighLevelILBasicBlock, self).__init__(handle, view)
-		self.il_function = owner
+		self._il_function = owner
 
-	def __iter__(self):
+	def __iter__(self) -> Generator[HighLevelILInstruction, None, None]:
 		for idx in range(self.start, self.end):
 			yield self.il_function[idx]
 
-	def __getitem__(self, idx):
+	def __getitem__(self, idx) -> HighLevelILInstruction:
 		size = self.end - self.start
 		if isinstance(idx, slice):
 			return [self[index] for index in range(*idx.indices(size))]
@@ -1038,7 +1080,7 @@ class HighLevelILBasicBlock(basicblock.BasicBlock):
 		else:
 			return self.il_function[self.end + idx]
 
-	def _create_instance(self, handle, view):
+	def _create_instance(self, handle:core.BNBasicBlock, view:'binaryview.BinaryView'):
 		"""Internal method by super to instantiate child instances"""
 		return HighLevelILBasicBlock(view, handle, self.il_function)
 
@@ -1054,10 +1096,9 @@ class HighLevelILBasicBlock(basicblock.BasicBlock):
 			return False
 
 	@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) -> HighLevelILFunction:
+		return self._il_function