From 72ea7b177f8dee446b505f887200b1751fa465fb Mon Sep 17 00:00:00 2001
From: Gusarich <danielsedovzzz@gmail.com>
Date: Mon, 14 Oct 2024 14:00:44 +0300
Subject: [PATCH] fix: adjust comparing and hashing and a few tests

---
 src/grammar/compare.ts                               | 10 ++++++----
 src/grammar/hash.ts                                  |  6 +++---
 src/test/contracts/case-destructuring.tact           | 12 ++++++------
 .../renamer-expected/case-destructuring.tact         | 12 ++++++------
 4 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/src/grammar/compare.ts b/src/grammar/compare.ts
index 18a5ccd84..d744caecc 100644
--- a/src/grammar/compare.ts
+++ b/src/grammar/compare.ts
@@ -582,10 +582,12 @@ export class AstComparator {
                     identifiers: destructIdentifiers2,
                     expression: destructExpression2,
                 } = node2 as AstStatementDestruct;
-                const sortedIdentifiers1 =
-                    Array.from(destructIdentifiers1).sort();
-                const sortedIdentifiers2 =
-                    Array.from(destructIdentifiers2).sort();
+                const sortedIdentifiers1 = Array.from(
+                    destructIdentifiers1.values(),
+                ).sort();
+                const sortedIdentifiers2 = Array.from(
+                    destructIdentifiers2.values(),
+                ).sort();
                 if (sortedIdentifiers1.length !== sortedIdentifiers2.length) {
                     return false;
                 }
diff --git a/src/grammar/hash.ts b/src/grammar/hash.ts
index ac2010198..3a1582f13 100644
--- a/src/grammar/hash.ts
+++ b/src/grammar/hash.ts
@@ -130,7 +130,7 @@ export class AstHasher {
             case "statement_foreach":
                 return `${node.kind}|${this.hash(node.map)}|${this.hashStatements(node.statements)}`;
             case "statement_destruct":
-                return `${node.kind}|${this.hash(node.type)}|${this.hashDestructIdentifiers(node.identifiers)}|${this.hash(node.expression)}`;
+                return `${node.kind}|${this.hash(node.type)}|${this.hashDestructIdentifiers(Array.from(node.identifiers.values()))}|${this.hash(node.expression)}`;
             // Expressions
             case "op_binary":
                 return `${node.kind}|${node.op}|${this.hash(node.left)}|${this.hash(node.right)}`;
@@ -195,8 +195,8 @@ export class AstHasher {
         }
     }
 
-    private hashDestructIdentifiers(identifiers: Map<AstId, AstId>): string {
-        const identifiersHash = Array.from(identifiers)
+    private hashDestructIdentifiers(identifiers: [AstId, AstId][]): string {
+        const identifiersHash = identifiers
             .map(([key, value]) => `${this.hash(key)}|${this.hash(value)}`)
             .join("|");
         return identifiersHash;
diff --git a/src/test/contracts/case-destructuring.tact b/src/test/contracts/case-destructuring.tact
index 9902430b5..8a4c89170 100644
--- a/src/test/contracts/case-destructuring.tact
+++ b/src/test/contracts/case-destructuring.tact
@@ -12,12 +12,12 @@ message M {
 fun testFunc(): Int {
     let s = S{a: 1, b: 2, c: 3};
     let S {a, b, c} = s;
-    let S {a: a1, _, _} = s;
-    let S {_, b: b1, _} = s;
-    let S {_, _, c: c1} = s;
-    let S {a: a2, b: b2, _} = s;
-    let S {a: a3, _, c: c3} = s;
-    let S {_, b: b4, c: c4} = s;
+    let S {a: a1} = s;
+    let S {b: b1} = s;
+    let S {c: c1} = s;
+    let S {a: a2, b: b2} = s;
+    let S {a: a3, c: c3} = s;
+    let S {b: b4, c: c4} = s;
     let m = M{a: 1, b: 2};
     let M {a: a_m, b: b_m} = m;
     return a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4 + c4 + a_m + b_m;
diff --git a/src/test/contracts/renamer-expected/case-destructuring.tact b/src/test/contracts/renamer-expected/case-destructuring.tact
index f6ba6b369..c11334837 100644
--- a/src/test/contracts/renamer-expected/case-destructuring.tact
+++ b/src/test/contracts/renamer-expected/case-destructuring.tact
@@ -12,12 +12,12 @@ message message_decl_1 {
 fun function_def_2(): Int {
     let s = S{a: 1, b: 2, c: 3};
     let S {a, b, c} = s;
-    let S {a: a1, _, _} = s;
-    let S {_, b: b1, _} = s;
-    let S {_, _, c: c1} = s;
-    let S {a: a2, b: b2, _} = s;
-    let S {a: a3, _, c: c3} = s;
-    let S {_, b: b4, c: c4} = s;
+    let S {a: a1} = s;
+    let S {b: b1} = s;
+    let S {c: c1} = s;
+    let S {a: a2, b: b2} = s;
+    let S {a: a3, c: c3} = s;
+    let S {b: b4, c: c4} = s;
     let m = M{a: 1, b: 2};
     let M {a: a_m, b: b_m} = m;
     return a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4 + c4 + a_m + b_m;