Convert the following to dataclasses:

AddressRange
BoolWithConfidence
ConstantReference
EnumerationMember
FunctionParameter
ILFlag
ILIntrinsic
ILRegister
ILRegisterStack
ILSemanticFlagClass
ILSemanticFlagGroup
IndirectBranchInfo
InstructionBranch
InstructionInfo
IntrinsicInfo
IntrinsicInput
LowLevelILExpr
LowLevelILOperationAndSize
PossibleValueSet
RegisterInfo
RegisterSet
RegisterStackAdjustmentWithConfidence
RegisterStackInfo
SSAFlag
SSARegister
SSARegisterOrFlag
SSARegisterStack
SizeWithConfidence
StackVariableReference
StructureMember
TypeFieldReference
TypeParserResult
ValueRange
BasicBlockEdge

1 files changed, 60 insertions, 168 deletions

diff --git a/python/variable.py b/python/variable.py
index 0b793c15..1e496797 100644
--- a/python/variable.py
+++ b/python/variable.py
@@ -21,7 +21,7 @@
 
 import ctypes
 from typing import List, Generator, Optional, Union, Set, Mapping
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 import binaryninja
 from . import _binaryninjacore as core
@@ -39,9 +39,6 @@ class LookupTableEntry(object):
 	def type(self):
 		return RegisterValueType.LookupTableValue
 
-@dataclass(frozen=True)
-class Confidence:
-	confidence:int=core.max_confidence
 
 @dataclass(frozen=True)
 class RegisterValue:
@@ -52,16 +49,14 @@ class RegisterValue:
 
 	def _to_api_object(self):
 		result = core.BNRegisterValue()
-		result.type = self.type
-		result._value = self.value
+		result.state = self.type
+		result.value = self.value
 		result.offset = self.offset
 		return result
 
 	def _to_api_object_with_confidence(self):
-		result = core.BNRegisterValue()
-		result.type = self.type
-		result._value = self.value
-		result.offset = self.offset
+		result = core.BNRegisterValueWithConfidence()
+		result.value = self._to_api_object()
 		result.confidence = self.confidence
 		return result
 
@@ -87,6 +82,7 @@ class RegisterValue:
 		confidence = core.max_confidence
 		if isinstance(reg_value, core.BNRegisterValueWithConfidence):
 			confidence = reg_value.confidence
+			reg_value = reg_value.value
 		if reg_value.state == RegisterValueType.EntryValue:
 			reg = None
 			if arch is not None:
@@ -94,14 +90,18 @@ class RegisterValue:
 			return EntryRegisterValue(reg_value.value, reg=reg, confidence=confidence)
 		elif reg_value.state == RegisterValueType.ConstantValue:
 			return ConstantRegisterValue(reg_value.value, confidence=confidence)
-		elif reg_value.state == RegisterValueType.ConstantValue:
+		elif reg_value.state == RegisterValueType.ConstantPointerValue:
 			return ConstantPointerRegisterValue(reg_value.value, confidence=confidence)
 		elif reg_value.state == RegisterValueType.StackFrameOffset:
-			return StackFrameOffsetRegisterValue(reg_value.value, reg_value.offset, confidence=confidence)
+			return StackFrameOffsetRegisterValue(reg_value.value, confidence=confidence)
 		elif reg_value.state == RegisterValueType.ImportedAddressValue:
 			return ImportedAddressRegisterValue(reg_value.value, confidence=confidence)
 		elif reg_value.state == RegisterValueType.UndeterminedValue:
 			return Undetermined()
+		elif reg_value.state == RegisterValueType.ReturnAddressValue:
+			return ReturnAddressRegisterValue(reg_value.value, confidence=confidence)
+		elif reg_value.state == RegisterValueType.ExternalPointerValue:
+			return ExternalPointerRegisterValue(reg_value.value, reg_value.offset, confidence=confidence)
 		assert False, f"RegisterValueType {reg_value.state} not handled"
 
 
@@ -111,6 +111,9 @@ class Undetermined(RegisterValue):
 	offset:int = 0
 	type:RegisterValueType = RegisterValueType.UndeterminedValue
 
+	def __repr__(self):
+		return "<undetermined>"
+
 
 @dataclass(frozen=True, eq=False)
 class ConstantRegisterValue(RegisterValue):
@@ -156,19 +159,18 @@ class EntryRegisterValue(RegisterValue):
 	reg:Optional['binaryninja.architecture.RegisterName'] = None
 
 	def __repr__(self):
+		if self.reg is not None:
+			return f"<entry {self.reg}>"
 		return f"<entry {self.value}>"
 
-	@classmethod
-	def from_BNRegisterValue(cls, value:core.BNRegisterValue):
-		cls(value.state, value.value, value.offset)
-
 
 @dataclass(frozen=True, eq=False)
 class StackFrameOffsetRegisterValue(RegisterValue):
+	offset:int = 0
 	type:RegisterValueType = RegisterValueType.StackFrameOffset
 
 	def __repr__(self):
-		return f"<stack frame offset {self.offset:#x}>"
+		return f"<stack frame offset {self.value:#x}>"
 
 @dataclass(frozen=True, eq=False)
 class ExternalPointerRegisterValue(RegisterValue):
@@ -177,39 +179,22 @@ class ExternalPointerRegisterValue(RegisterValue):
 	def __repr__(self):
 		return f"<external {self.value:#x} + offset {self.offset:#x}>"
 
-@decorators.passive
+
+@dataclass(frozen=True)
 class ValueRange(object):
-	def __init__(self, start, end, step):
-		self._start = start
-		self._end = end
-		self._step = step
+	start:int
+	end:int
+	step:int
 
 	def __repr__(self):
 		if self.step == 1:
 			return f"<range: {self.start:#x} to {self.end:#x}>"
 		return f"<range: {self.start:#x} to {self.end:#x}, step {self.step:#x}>"
 
-	def __eq__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return self.start == other.start and self.end == other.end and self.step == other.step
-
 	def __contains__(self, other):
 		if not isinstance(other, int):
 			return NotImplemented
-		return other in range(self._start, self._end, self._step)
-
-	@property
-	def start(self):
-		return self._start
-
-	@property
-	def end(self):
-		return self._end
-
-	@property
-	def step(self):
-		return self._step
+		return other in range(self.start, self.end, self.step)
 
 
 @decorators.passive
@@ -390,7 +375,8 @@ class PossibleValueSet(object):
 			for value in self.values:
 				values[i] = value
 				i += 1
-			result.valueSet = ctypes.cast(values, ctypes.POINTER(ctypes.c_longlong))
+			int_ptr = ctypes.POINTER(ctypes.c_longlong)
+			result.valueSet = ctypes.cast(values, int_ptr)
 			result.count = self.count
 		return result
 
@@ -566,67 +552,31 @@ class PossibleValueSet(object):
 		return result
 
 
-@decorators.passive
+@dataclass(frozen=True)
 class StackVariableReference(object):
-	def __init__(self, src_operand, t, name, var, ref_ofs, size):
-		self._source_operand = src_operand
-		self._type = t
-		self._name = name
-		self._var = var
-		self._referenced_offset = ref_ofs
-		self._size = size
-		if self._source_operand == 0xffffffff:
-			self._source_operand = None
+	_source_operand:Optional[int]
+	type:'binaryninja.types.Type'
+	name:str
+	var:'Variable'
+	referenced_offset:int
+	size:int
 
 	def __repr__(self):
-		if self._source_operand is None:
-			if self._referenced_offset != self._var.storage:
-				return "<ref to %s%+#x>" % (self._name, self._referenced_offset - self._var.storage)
-			return "<ref to %s>" % self._name
-		if self._referenced_offset != self._var.storage:
-			return "<operand %d ref to %s%+#x>" % (self._source_operand, self._name, self._var.storage)
-		return "<operand %d ref to %s>" % (self._source_operand, self._name)
-
-	def __eq__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return (self._source_operand, self._type, self._name, self._var, self._referenced_offset, self._size) == \
-			(other._source_operand, other._type, other._name, other._var, other._referenced_offset, other._size)
-
-	def __ne__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return not (self == other)
-
-	def __hash__(self):
-		return hash((self._source_operand, self._type, self._name, self._var, self._referenced_offset, self._size))
+		if self.source_operand is None:
+			if self.referenced_offset != self.var.storage:
+				return f"<ref to {self.name}{self.referenced_offset - self.var.storage:+#x}>"
+			return f"<ref to {self.name}>"
+		if self.referenced_offset != self.var.storage:
+			return f"<operand {self.source_operand} ref to {self.var.storage}{self.var.storage:+#x}>"
+		return f"<operand {self.source_operand} ref to {self.name}>"
 
 	@property
 	def source_operand(self):
+		if self._source_operand == 0xffffffff:
+			return None
 		return self._source_operand
 
-	@property
-	def type(self):
-		return self._type
-
-	@property
-	def name(self):
-		return self._name
 
-	@property
-	def var(self):
-		return self._var
-
-	@property
-	def referenced_offset(self):
-		return self._referenced_offset
-
-	@property
-	def size(self):
-		return self._size
-
-
-@decorators.passive
 @dataclass(frozen=True, order=True)
 class CoreVariable:
 	_source_type:int
@@ -657,7 +607,7 @@ class CoreVariable:
 		var = core.BNFromVariableIdentifier(identifier)
 		return cls(var.type, var.index, var.storage)
 
-@decorators.passive
+
 @dataclass(frozen=True, order=True)
 class VariableNameAndType(CoreVariable):
 	name:str
@@ -792,13 +742,12 @@ class Variable:
 	def to_BNVariable(self):
 		return self._var.to_BNVariable()
 
-@decorators.passive
+@dataclass(frozen=True)
 class ConstantReference(object):
-	def __init__(self, val, size, ptr, intermediate):
-		self._value = val
-		self._size = size
-		self._pointer = ptr
-		self._intermediate = intermediate
+	value:int
+	size:int
+	pointer:bool
+	intermediate:bool
 
 	def __repr__(self):
 		if self.pointer:
@@ -807,45 +756,17 @@ class ConstantReference(object):
 			return "<constant %#x>" % self.value
 		return "<constant %#x size %d>" % (self.value, self.size)
 
-	@property
-	def value(self):
-		return self._value
-
-	@property
-	def size(self):
-		return self._size
-
-	@property
-	def pointer(self):
-		return self._pointer
-
-	@property
-	def intermediate(self):
-		return self._intermediate
-
-
-@decorators.passive
-class UserVariableValueInfo(object):
-	def __init__(self, var, def_site, value):
-		self.var = var
-		self.def_site = def_site
-		self.value = value
-
-	def __repr__(self):
-		return "<user value for %s @ %s:%#x -> %s>" % (self.var, self.def_site.arch.name, self.def_site.addr, self.value)
 
-
-@decorators.passive
+@dataclass(frozen=True)
 class IndirectBranchInfo(object):
-	def __init__(self, source_arch, source_addr, dest_arch, dest_addr, auto_defined):
-		self.source_arch = source_arch
-		self.source_addr = source_addr
-		self.dest_arch = dest_arch
-		self.dest_addr = dest_addr
-		self.auto_defined = auto_defined
+	source_arch:'binaryninja.architecture.Architecture'
+	source_addr:int
+	dest_arch:'binaryninja.architecture.Architecture'
+	dest_addr:int
+	auto_defined:bool
 
 	def __repr__(self):
-		return "<branch %s:%#x -> %s:%#x>" % (self.source_arch.name, self.source_addr, self.dest_arch.name, self.dest_addr)
+		return f"<branch {self.source_arch.name}:{self.source_addr:#x} -> {self.dest_arch.name}:{self.dest_addr:#x}>"
 
 
 @decorators.passive
@@ -889,39 +810,10 @@ class ParameterVariables(object):
 		return self._func
 
 
-@decorators.passive
+@dataclass(frozen=True, order=True)
 class AddressRange(object):
-	def __init__(self, start:int, end:int):
-		self._start = start
-		self._end = end
+	start:int
+	end:int
 
 	def __repr__(self):
-		return "<%#x-%#x>" % (self._start, self._end)
-
-	def __len__(self):
-		return self._end - self.start
-
-	def __eq__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return (self._start, self._end) == (other._start, other._end)
-
-	def __ne__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return not (self == other)
-
-	def __hash__(self):
-		return hash((self._start, self._end))
-
-	@property
-	def length(self) -> int:
-		return self._end - self._start
-
-	@property
-	def start(self) -> int:
-		return self._start
-
-	@property
-	def end(self) -> int:
-		return self._end
\ No newline at end of file
+		return f"<{self.start:#x}-{self.end:#x}>"
\ No newline at end of file