Add collapse region identifier types

plafosse · plafosse · commit 712f6abeaec1 · 2026-07-10T20:00:46.000-04:00
diff --git a/binaryninjaapi.h b/binaryninjaapi.h
@@ -6455,11 +6455,11 @@ namespace BinaryNinja {
 		*/
 		bool GetDataVariableAtAddress(uint64_t addr, DataVariable& var);
 
-		bool IsDataVariableRegionCollapsed(uint64_t hash) const;
-		void CollapseDataVariableRegion(uint64_t hash);
-		void ExpandDataVariableRegion(uint64_t hash);
+		bool IsDataVariableRegionCollapsed(BNCollapseRegionId id) const;
+		void CollapseDataVariableRegion(BNCollapseRegionId id);
+		void ExpandDataVariableRegion(BNCollapseRegionId id);
 		void ExpandAllDataVariableRegions();
-		void ToggleDataVariableRegion(uint64_t hash);
+		void ToggleDataVariableRegion(BNCollapseRegionId id);
 		bool IsSectionRegionCollapsed(Section* section) const;
 		void CollapseSectionRegion(Section* section);
 		void ExpandSectionRegion(Section* section);
@@ -13151,7 +13151,7 @@ namespace BinaryNinja {
 	{
 		int m_advancedAnalysisRequests;
 
-		bool IsRegionCollapsed(uint64_t hash) const;
+		bool IsRegionCollapsed(BNCollapseRegionId id) const;
 
 	  public:
 		Function(BNFunction* func);
@@ -13862,11 +13862,12 @@ namespace BinaryNinja {
 		};
 
 		// TODO: Documentation
-		bool IsInstructionCollapsed(const HighLevelILInstruction& instr, uint64_t designator = 0) const;
+		bool IsInstructionCollapsed(
+			const HighLevelILInstruction& instr, BNCollapseRegionDesignator designator = 0) const;
 		bool IsCollapsed() const;
-		void ToggleRegion(uint64_t hash);
-		void CollapseRegion(uint64_t hash);
-		void ExpandRegion(uint64_t hash);
+		void ToggleRegion(BNCollapseRegionId id);
+		void CollapseRegion(BNCollapseRegionId id);
+		void ExpandRegion(BNCollapseRegionId id);
 		void ExpandAll();
 
 		void StoreMetadata(const std::string& key, Ref<Metadata> value, bool isAuto = false);
@@ -22704,12 +22705,13 @@ namespace BinaryNinja {
 		}
 
 		void PrependCollapseIndicator();
-		void PrependCollapseIndicator(Ref<Function> function, const HighLevelILInstruction& instr, uint64_t designator = 0);
 		void PrependCollapseIndicator(Ref<Function> function, const HighLevelILInstruction& instr,
-			DisassemblySettings* settings, uint64_t designator = 0);
-		void PrependCollapseIndicator(BNInstructionTextTokenContext context, uint64_t hash);
+			BNCollapseRegionDesignator designator = 0);
+		void PrependCollapseIndicator(Ref<Function> function, const HighLevelILInstruction& instr,
+			DisassemblySettings* settings, BNCollapseRegionDesignator designator = 0);
+		void PrependCollapseIndicator(BNInstructionTextTokenContext context, BNCollapseRegionId id);
 		static bool IsInstructionCollapsed(Ref<Function> function, const HighLevelILInstruction& instr,
-			DisassemblySettings* settings, uint64_t designator = 0);
+			DisassemblySettings* settings, BNCollapseRegionDesignator designator = 0);
 		bool HasCollapsableRegions();
 		void SetHasCollapsableRegions(bool state);
 
diff --git a/binaryninjacore.h b/binaryninjacore.h
@@ -141,6 +141,12 @@
 
 #define BN_MAX_STRING_LENGTH 128
 
+/*! Identifier for a collapsible region in a rendered view. */
+typedef uint64_t BNCollapseRegionId;
+
+/*! Selector used to distinguish collapsible regions associated with the same rendered object. */
+typedef uint64_t BNCollapseRegionDesignator;
+
 #define LLVM_SVCS_CB_NOTE    0
 #define LLVM_SVCS_CB_WARNING 1
 #define LLVM_SVCS_CB_ERROR   2
@@ -5358,11 +5364,11 @@ extern "C"
 	BINARYNINJACOREAPI bool BNHasFunctions(BNBinaryView* view);
 	BINARYNINJACOREAPI bool BNHasSymbols(BNBinaryView* view);
 	BINARYNINJACOREAPI bool BNHasDataVariables(BNBinaryView* view);
-	BINARYNINJACOREAPI bool BNIsDataVariableRegionCollapsed(BNBinaryView* view, uint64_t hash);
-	BINARYNINJACOREAPI void BNCollapseDataVariableRegion(BNBinaryView* view, uint64_t hash);
-	BINARYNINJACOREAPI void BNExpandDataVariableRegion(BNBinaryView* view, uint64_t hash);
+	BINARYNINJACOREAPI bool BNIsDataVariableRegionCollapsed(BNBinaryView* view, BNCollapseRegionId id);
+	BINARYNINJACOREAPI void BNCollapseDataVariableRegion(BNBinaryView* view, BNCollapseRegionId id);
+	BINARYNINJACOREAPI void BNExpandDataVariableRegion(BNBinaryView* view, BNCollapseRegionId id);
 	BINARYNINJACOREAPI void BNExpandAllDataVariableRegions(BNBinaryView* view);
-	BINARYNINJACOREAPI void BNToggleDataVariableRegion(BNBinaryView* view, uint64_t hash);
+	BINARYNINJACOREAPI void BNToggleDataVariableRegion(BNBinaryView* view, BNCollapseRegionId id);
 	BINARYNINJACOREAPI bool BNIsSectionRegionCollapsed(BNBinaryView* view, BNSection* section);
 	BINARYNINJACOREAPI void BNCollapseSectionRegion(BNBinaryView* view, BNSection* section);
 	BINARYNINJACOREAPI void BNExpandSectionRegion(BNBinaryView* view, BNSection* section);
@@ -5868,11 +5874,11 @@ extern "C"
 	BINARYNINJACOREAPI BNArchitectureAndAddress* BNGetUnresolvedIndirectBranches(BNFunction* func, size_t* count);
 	BINARYNINJACOREAPI bool BNHasUnresolvedIndirectBranches(BNFunction* func);
 
-	BINARYNINJACOREAPI void BNFunctionToggleRegion(BNFunction* func, uint64_t hash);
-	BINARYNINJACOREAPI bool BNFunctionIsRegionCollapsed(BNFunction* func, uint64_t hash);
+	BINARYNINJACOREAPI void BNFunctionToggleRegion(BNFunction* func, BNCollapseRegionId id);
+	BINARYNINJACOREAPI bool BNFunctionIsRegionCollapsed(BNFunction* func, BNCollapseRegionId id);
 	BINARYNINJACOREAPI void BNFunctionExpandAll(BNFunction* func);
-	BINARYNINJACOREAPI void BNFunctionCollapseRegion(BNFunction* func,  uint64_t hash);
-	BINARYNINJACOREAPI void BNFunctionExpandRegion(BNFunction* func, uint64_t hash);
+	BINARYNINJACOREAPI void BNFunctionCollapseRegion(BNFunction* func, BNCollapseRegionId id);
+	BINARYNINJACOREAPI void BNFunctionExpandRegion(BNFunction* func, BNCollapseRegionId id);
 
 	BINARYNINJACOREAPI void BNFunctionStoreMetadata(
 	    BNFunction* func, const char* key, BNMetadata* value, bool isAuto);
@@ -9197,7 +9203,8 @@ extern "C"
 	// High level token emitter
 	BINARYNINJACOREAPI BNHighLevelILTokenEmitter* BNNewHighLevelILTokenEmitterReference(BNHighLevelILTokenEmitter* emitter);
 	BINARYNINJACOREAPI void BNHighLevelILTokenPrependCollapseBlankIndicator(BNHighLevelILTokenEmitter* emitter);
-	BINARYNINJACOREAPI void BNHighLevelILTokenPrependCollapseIndicator(BNHighLevelILTokenEmitter* emitter, BNInstructionTextTokenContext context, uint64_t hash);
+	BINARYNINJACOREAPI void BNHighLevelILTokenPrependCollapseIndicator(
+		BNHighLevelILTokenEmitter* emitter, BNInstructionTextTokenContext context, BNCollapseRegionId id);
 	BINARYNINJACOREAPI bool BNHighLevelILTokenEmitterHasCollapsableRegions(BNHighLevelILTokenEmitter* emitter);
 	BINARYNINJACOREAPI void BNHighLevelILTokenEmitterSetHasCollapsableRegions(BNHighLevelILTokenEmitter* emitter, bool state);
 	BINARYNINJACOREAPI void BNFreeHighLevelILTokenEmitter(BNHighLevelILTokenEmitter* emitter);
diff --git a/binaryview.cpp b/binaryview.cpp
@@ -2310,21 +2310,21 @@ bool BinaryView::GetDataVariableAtAddress(uint64_t addr, DataVariable& var)
 }
 
 
-bool BinaryView::IsDataVariableRegionCollapsed(uint64_t hash) const
+bool BinaryView::IsDataVariableRegionCollapsed(BNCollapseRegionId id) const
 {
-	return BNIsDataVariableRegionCollapsed(m_object, hash);
+	return BNIsDataVariableRegionCollapsed(m_object, id);
 }
 
 
-void BinaryView::CollapseDataVariableRegion(uint64_t hash)
+void BinaryView::CollapseDataVariableRegion(BNCollapseRegionId id)
 {
-	BNCollapseDataVariableRegion(m_object, hash);
+	BNCollapseDataVariableRegion(m_object, id);
 }
 
 
-void BinaryView::ExpandDataVariableRegion(uint64_t hash)
+void BinaryView::ExpandDataVariableRegion(BNCollapseRegionId id)
 {
-	BNExpandDataVariableRegion(m_object, hash);
+	BNExpandDataVariableRegion(m_object, id);
 }
 
 
@@ -2334,9 +2334,9 @@ void BinaryView::ExpandAllDataVariableRegions()
 }
 
 
-void BinaryView::ToggleDataVariableRegion(uint64_t hash)
+void BinaryView::ToggleDataVariableRegion(BNCollapseRegionId id)
 {
-	BNToggleDataVariableRegion(m_object, hash);
+	BNToggleDataVariableRegion(m_object, id);
 }
 
 
diff --git a/function.cpp b/function.cpp
@@ -3363,21 +3363,21 @@ void Function::SetUserInlinedDuringAnalysis(Confidence<BNInlineDuringAnalysis> i
 }
 
 
-void Function::ToggleRegion(uint64_t hash)
+void Function::ToggleRegion(BNCollapseRegionId id)
 {
-	BNFunctionToggleRegion(m_object, hash);
+	BNFunctionToggleRegion(m_object, id);
 }
 
 
-void Function::CollapseRegion(uint64_t hash)
+void Function::CollapseRegion(BNCollapseRegionId id)
 {
-	BNFunctionCollapseRegion(m_object, hash);
+	BNFunctionCollapseRegion(m_object, id);
 }
 
 
-void Function::ExpandRegion(uint64_t hash)
+void Function::ExpandRegion(BNCollapseRegionId id)
 {
-	BNFunctionExpandRegion(m_object, hash);
+	BNFunctionExpandRegion(m_object, id);
 }
 
 
@@ -3387,15 +3387,16 @@ bool Function::IsCollapsed() const
 }
 
 
-bool Function::IsInstructionCollapsed(const HighLevelILInstruction& instr, uint64_t designator) const
+bool Function::IsInstructionCollapsed(
+	const HighLevelILInstruction& instr, BNCollapseRegionDesignator designator) const
 {
 	return IsRegionCollapsed(instr.GetInstructionHash(designator));
 }
 
 
-bool Function::IsRegionCollapsed(uint64_t hash) const
+bool Function::IsRegionCollapsed(BNCollapseRegionId id) const
 {
-	return BNFunctionIsRegionCollapsed(m_object, hash);
+	return BNFunctionIsRegionCollapsed(m_object, id);
 }
 
 
diff --git a/highlevelil.cpp b/highlevelil.cpp
@@ -691,13 +691,15 @@ void HighLevelILTokenEmitter::PrependCollapseIndicator()
 }
 
 
-void HighLevelILTokenEmitter::PrependCollapseIndicator(Ref<Function> function, const HighLevelILInstruction& instr, uint64_t designator)
+void HighLevelILTokenEmitter::PrependCollapseIndicator(
+	Ref<Function> function, const HighLevelILInstruction& instr, BNCollapseRegionDesignator designator)
 {
 	PrependCollapseIndicator(function, instr, nullptr, designator);
 }
 
 void HighLevelILTokenEmitter::PrependCollapseIndicator(
-	Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings, uint64_t designator)
+	Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings,
+	BNCollapseRegionDesignator designator)
 {
 	if (!HasCollapsableRegions())
 		return;
@@ -712,13 +714,14 @@ void HighLevelILTokenEmitter::PrependCollapseIndicator(
 	PrependCollapseIndicator(context, instr.GetInstructionHash(designator));
 }
 
-void HighLevelILTokenEmitter::PrependCollapseIndicator(BNInstructionTextTokenContext context, uint64_t hash)
+void HighLevelILTokenEmitter::PrependCollapseIndicator(BNInstructionTextTokenContext context, BNCollapseRegionId id)
 {
-	BNHighLevelILTokenPrependCollapseIndicator(m_object, context, hash);
+	BNHighLevelILTokenPrependCollapseIndicator(m_object, context, id);
 }
 
 bool HighLevelILTokenEmitter::IsInstructionCollapsed(
-	Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings, uint64_t designator)
+	Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings,
+	BNCollapseRegionDesignator designator)
 {
 	if (settings && settings->IsOptionSet(ShowCollapsedRegions))
 		return false;
diff --git a/highlevelilinstruction.h b/highlevelilinstruction.h
@@ -420,7 +420,7 @@ namespace BinaryNinja
 
 		bool HasParent() const;
 		HighLevelILInstruction GetParent() const;
-		uint64_t GetInstructionHash(size_t discriminator = 0) const
+		BNCollapseRegionId GetInstructionHash(BNCollapseRegionDesignator discriminator = 0) const
 		{
 			constexpr auto rotl = [](uint64_t value, int shift)
 			{ return (value << shift) | (value >> (64 - shift)); };
diff --git a/python/binaryview.py b/python/binaryview.py
@@ -5987,20 +5987,20 @@ def get_data_var_at(self, addr: int) -> Optional['DataVariable']:
 		core.BNFreeDataVariable(var)
 		return result
 
-	def is_data_variable_region_collapsed(self, region_hash: int) -> bool:
-		return core.BNIsDataVariableRegionCollapsed(self.handle, region_hash)
+	def is_data_variable_region_collapsed(self, region_id: int) -> bool:
+		return core.BNIsDataVariableRegionCollapsed(self.handle, region_id)
 
-	def collapse_data_variable_region(self, region_hash: int) -> None:
-		core.BNCollapseDataVariableRegion(self.handle, region_hash)
+	def collapse_data_variable_region(self, region_id: int) -> None:
+		core.BNCollapseDataVariableRegion(self.handle, region_id)
 
-	def expand_data_variable_region(self, region_hash: int) -> None:
-		core.BNExpandDataVariableRegion(self.handle, region_hash)
+	def expand_data_variable_region(self, region_id: int) -> None:
+		core.BNExpandDataVariableRegion(self.handle, region_id)
 
 	def expand_all_data_variable_regions(self) -> None:
 		core.BNExpandAllDataVariableRegions(self.handle)
 
-	def toggle_data_variable_region(self, region_hash: int) -> None:
-		core.BNToggleDataVariableRegion(self.handle, region_hash)
+	def toggle_data_variable_region(self, region_id: int) -> None:
+		core.BNToggleDataVariableRegion(self.handle, region_id)
 
 	def is_section_region_collapsed(self, section: Section) -> bool:
 		return core.BNIsSectionRegionCollapsed(self.handle, section.handle)
diff --git a/python/function.py b/python/function.py
@@ -3699,26 +3699,26 @@ def set_user_inline_during_analysis(self, value: Union['types.InlineDuringAnalys
 		value = self._inline_during_analysis_with_confidence(value)
 		core.BNSetUserFunctionInlinedDuringAnalysis(self.handle, value)
 
-	def toggle_region(self, hash):
+	def toggle_region(self, region_id: int):
 		"""
-		Toggle the collapsed state of a region during rendering, by hash value
-		:param hash: Hash value of region
+		Toggle the collapsed state of a region during rendering.
+		:param region_id: Identifier of the region
 		"""
-		core.BNFunctionToggleRegion(self.handle, hash)
+		core.BNFunctionToggleRegion(self.handle, region_id)
 
-	def collapse_region(self, hash):
+	def collapse_region(self, region_id: int):
 		"""
 		Collapse a region during rendering
-		:param hash: Hash value of region
+		:param region_id: Identifier of the region
 		"""
-		core.BNFunctionCollapseRegion(self.handle, hash)
+		core.BNFunctionCollapseRegion(self.handle, region_id)
 
-	def expand_region(self, hash):
+	def expand_region(self, region_id: int):
 		"""
 		Un-collapse a region during rendering
-		:param hash: Hash value of region
+		:param region_id: Identifier of the region
 		"""
-		core.BNFunctionExpandRegion(self.handle, hash)
+		core.BNFunctionExpandRegion(self.handle, region_id)
 
 	def expand_all(self):
 		"""
@@ -3744,13 +3744,13 @@ def is_instruction_collapsed(
 		"""
 		return self.is_region_collapsed(instr.get_instruction_hash(discriminator))
 
-	def is_region_collapsed(self, hash) -> bool:
+	def is_region_collapsed(self, region_id: int) -> bool:
 		"""
 		Determine if a given region is collapsed during rendering.
-		:param hash: Hash value of region
+		:param region_id: Identifier of the region
 		:return: True if the region should be rendered as collapsed
 		"""
-		return core.BNFunctionIsRegionCollapsed(self.handle, hash)
+		return core.BNFunctionIsRegionCollapsed(self.handle, region_id)
 
 	def store_metadata(self, key: str, md: metadata.MetadataValueType, isAuto: bool = False) -> None:
 		"""
diff --git a/python/languagerepresentation.py b/python/languagerepresentation.py
@@ -137,9 +137,9 @@ def prepend_instr_collapse_indicator(
 	def prepend_region_collapse_indicator(
 		self,
 		context: InstructionTextTokenContext,
-		hash: int
+		region_id: int
 	):
-		core.BNHighLevelILTokenPrependCollapseIndicator(self.handle, context, hash)
+		core.BNHighLevelILTokenPrependCollapseIndicator(self.handle, context, region_id)
 
 	@property
 	def has_collapsable_regions(self) -> bool:
diff --git a/rust/src/high_level_il/token_emitter.rs b/rust/src/high_level_il/token_emitter.rs
@@ -44,9 +44,13 @@ impl HighLevelILTokenEmitter {
         unsafe { BNHighLevelILTokenPrependCollapseBlankIndicator(self.handle.as_ptr()) };
     }
 
-    pub fn prepend_collapse_indicator(&self, context: InstructionTextTokenContext, hash: u64) {
+    pub fn prepend_collapse_indicator(
+        &self,
+        context: InstructionTextTokenContext,
+        id: BNCollapseRegionId,
+    ) {
         unsafe {
-            BNHighLevelILTokenPrependCollapseIndicator(self.handle.as_ptr(), context.into(), hash)
+            BNHighLevelILTokenPrependCollapseIndicator(self.handle.as_ptr(), context.into(), id)
         };
     }
 

Original file line number	Diff line number	Diff line change
`@@ -2310,21 +2310,21 @@ bool BinaryView::GetDataVariableAtAddress(uint64_t addr, DataVariable& var)`
`2310`	`2310`	`}`
`2311`	`2311`
`2312`	`2312`
`2313`		`-bool BinaryView::IsDataVariableRegionCollapsed(uint64_t hash) const`
	`2313`	`+bool BinaryView::IsDataVariableRegionCollapsed(BNCollapseRegionId id) const`
`2314`	`2314`	`{`
`2315`		`- return BNIsDataVariableRegionCollapsed(m_object, hash);`
	`2315`	`+ return BNIsDataVariableRegionCollapsed(m_object, id);`
`2316`	`2316`	`}`
`2317`	`2317`
`2318`	`2318`
`2319`		`-void BinaryView::CollapseDataVariableRegion(uint64_t hash)`
	`2319`	`+void BinaryView::CollapseDataVariableRegion(BNCollapseRegionId id)`
`2320`	`2320`	`{`
`2321`		`- BNCollapseDataVariableRegion(m_object, hash);`
	`2321`	`+ BNCollapseDataVariableRegion(m_object, id);`
`2322`	`2322`	`}`
`2323`	`2323`
`2324`	`2324`
`2325`		`-void BinaryView::ExpandDataVariableRegion(uint64_t hash)`
	`2325`	`+void BinaryView::ExpandDataVariableRegion(BNCollapseRegionId id)`
`2326`	`2326`	`{`
`2327`		`- BNExpandDataVariableRegion(m_object, hash);`
	`2327`	`+ BNExpandDataVariableRegion(m_object, id);`
`2328`	`2328`	`}`
`2329`	`2329`
`2330`	`2330`
`@@ -2334,9 +2334,9 @@ void BinaryView::ExpandAllDataVariableRegions()`
`2334`	`2334`	`}`
`2335`	`2335`
`2336`	`2336`
`2337`		`-void BinaryView::ToggleDataVariableRegion(uint64_t hash)`
	`2337`	`+void BinaryView::ToggleDataVariableRegion(BNCollapseRegionId id)`
`2338`	`2338`	`{`
`2339`		`- BNToggleDataVariableRegion(m_object, hash);`
	`2339`	`+ BNToggleDataVariableRegion(m_object, id);`
`2340`	`2340`	`}`
`2341`	`2341`
`2342`	`2342`
Original file line number	Diff line number	Diff line change
`@@ -3363,21 +3363,21 @@ void Function::SetUserInlinedDuringAnalysis(Confidence<BNInlineDuringAnalysis> i`
`3363`	`3363`	`}`
`3364`	`3364`
`3365`	`3365`
`3366`		`-void Function::ToggleRegion(uint64_t hash)`
	`3366`	`+void Function::ToggleRegion(BNCollapseRegionId id)`
`3367`	`3367`	`{`
`3368`		`- BNFunctionToggleRegion(m_object, hash);`
	`3368`	`+ BNFunctionToggleRegion(m_object, id);`
`3369`	`3369`	`}`
`3370`	`3370`
`3371`	`3371`
`3372`		`-void Function::CollapseRegion(uint64_t hash)`
	`3372`	`+void Function::CollapseRegion(BNCollapseRegionId id)`
`3373`	`3373`	`{`
`3374`		`- BNFunctionCollapseRegion(m_object, hash);`
	`3374`	`+ BNFunctionCollapseRegion(m_object, id);`
`3375`	`3375`	`}`
`3376`	`3376`
`3377`	`3377`
`3378`		`-void Function::ExpandRegion(uint64_t hash)`
	`3378`	`+void Function::ExpandRegion(BNCollapseRegionId id)`
`3379`	`3379`	`{`
`3380`		`- BNFunctionExpandRegion(m_object, hash);`
	`3380`	`+ BNFunctionExpandRegion(m_object, id);`
`3381`	`3381`	`}`
`3382`	`3382`
`3383`	`3383`
`@@ -3387,15 +3387,16 @@ bool Function::IsCollapsed() const`
`3387`	`3387`	`}`
`3388`	`3388`
`3389`	`3389`
`3390`		`-bool Function::IsInstructionCollapsed(const HighLevelILInstruction& instr, uint64_t designator) const`
	`3390`	`+bool Function::IsInstructionCollapsed(`
	`3391`	`+ const HighLevelILInstruction& instr, BNCollapseRegionDesignator designator) const`
`3391`	`3392`	`{`
`3392`	`3393`	`return IsRegionCollapsed(instr.GetInstructionHash(designator));`
`3393`	`3394`	`}`
`3394`	`3395`
`3395`	`3396`
`3396`		`-bool Function::IsRegionCollapsed(uint64_t hash) const`
	`3397`	`+bool Function::IsRegionCollapsed(BNCollapseRegionId id) const`
`3397`	`3398`	`{`
`3398`		`- return BNFunctionIsRegionCollapsed(m_object, hash);`
	`3399`	`+ return BNFunctionIsRegionCollapsed(m_object, id);`
`3399`	`3400`	`}`
`3400`	`3401`
`3401`	`3402`
Original file line number	Diff line number	Diff line change
`@@ -691,13 +691,15 @@ void HighLevelILTokenEmitter::PrependCollapseIndicator()`
`691`	`691`	`}`
`692`	`692`
`693`	`693`
`694`		`-void HighLevelILTokenEmitter::PrependCollapseIndicator(Ref<Function> function, const HighLevelILInstruction& instr, uint64_t designator)`
	`694`	`+void HighLevelILTokenEmitter::PrependCollapseIndicator(`
	`695`	`+ Ref<Function> function, const HighLevelILInstruction& instr, BNCollapseRegionDesignator designator)`
`695`	`696`	`{`
`696`	`697`	`PrependCollapseIndicator(function, instr, nullptr, designator);`
`697`	`698`	`}`
`698`	`699`
`699`	`700`	`void HighLevelILTokenEmitter::PrependCollapseIndicator(`
`700`		`- Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings, uint64_t designator)`
	`701`	`+ Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings,`
	`702`	`+ BNCollapseRegionDesignator designator)`
`701`	`703`	`{`
`702`	`704`	`if (!HasCollapsableRegions())`
`703`	`705`	`return;`
`@@ -712,13 +714,14 @@ void HighLevelILTokenEmitter::PrependCollapseIndicator(`
`712`	`714`	`PrependCollapseIndicator(context, instr.GetInstructionHash(designator));`
`713`	`715`	`}`
`714`	`716`
`715`		`-void HighLevelILTokenEmitter::PrependCollapseIndicator(BNInstructionTextTokenContext context, uint64_t hash)`
	`717`	`+void HighLevelILTokenEmitter::PrependCollapseIndicator(BNInstructionTextTokenContext context, BNCollapseRegionId id)`
`716`	`718`	`{`
`717`		`- BNHighLevelILTokenPrependCollapseIndicator(m_object, context, hash);`
	`719`	`+ BNHighLevelILTokenPrependCollapseIndicator(m_object, context, id);`
`718`	`720`	`}`
`719`	`721`
`720`	`722`	`bool HighLevelILTokenEmitter::IsInstructionCollapsed(`
`721`		`- Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings, uint64_t designator)`
	`723`	`+ Ref<Function> function, const HighLevelILInstruction& instr, DisassemblySettings* settings,`
	`724`	`+ BNCollapseRegionDesignator designator)`
`722`	`725`	`{`
`723`	`726`	`if (settings && settings->IsOptionSet(ShowCollapsedRegions))`
`724`	`727`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -420,7 +420,7 @@ namespace BinaryNinja`
`420`	`420`
`421`	`421`	`bool HasParent() const;`
`422`	`422`	`HighLevelILInstruction GetParent() const;`
`423`		`- uint64_t GetInstructionHash(size_t discriminator = 0) const`
	`423`	`+ BNCollapseRegionId GetInstructionHash(BNCollapseRegionDesignator discriminator = 0) const`
`424`	`424`	`{`
`425`	`425`	`constexpr auto rotl = [](uint64_t value, int shift)`
`426`	`426`	`{ return (value << shift) \| (value >> (64 - shift)); };`
Original file line number	Diff line number	Diff line change
`@@ -44,9 +44,13 @@ impl HighLevelILTokenEmitter {`
`44`	`44`	`unsafe { BNHighLevelILTokenPrependCollapseBlankIndicator(self.handle.as_ptr()) };`
`45`	`45`	`}`
`46`	`46`
`47`		`- pub fn prepend_collapse_indicator(&self, context: InstructionTextTokenContext, hash: u64) {`
	`47`	`+ pub fn prepend_collapse_indicator(`
	`48`	`+ &self,`
	`49`	`+ context: InstructionTextTokenContext,`
	`50`	`+ id: BNCollapseRegionId,`
	`51`	`+ ) {`
`48`	`52`	`unsafe {`
`49`		`- BNHighLevelILTokenPrependCollapseIndicator(self.handle.as_ptr(), context.into(), hash)`
	`53`	`+ BNHighLevelILTokenPrependCollapseIndicator(self.handle.as_ptr(), context.into(), id)`
`50`	`54`	`};`
`51`	`55`	`}`
`52`	`56`