From 7c82bffb2db973c774dda1e6e98bb2c4eca780aa Mon Sep 17 00:00:00 2001
From: "duanyi.aster" <duanyi.aster@bytedance.com>
Date: Thu, 10 Aug 2023 16:41:50 +0800
Subject: [PATCH] Break Change: drop ast.Node API `UnsafeArray()` and
 `UnsafeMap()`

---
 ast/node.go         | 36 +++++++++++-----------
 ast/node_test.go    | 74 ++++++++++++++++++++++-----------------------
 ast/visitor_test.go | 27 ++++++++++-------
 3 files changed, 71 insertions(+), 66 deletions(-)

diff --git a/ast/node.go b/ast/node.go
index 47272426c..444c8fe42 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -821,15 +821,15 @@ func (self *Node) MapUseNode() (map[string]Node, error) {
 // WARN: don't use it unless you know what you are doing
 //
 // Deprecated:  this API now returns copied nodes instead of directly reference, 
-func (self *Node) UnsafeMap() ([]Pair, error) {
-    if err := self.should(types.V_OBJECT, "an object"); err != nil {
-        return nil, err
-    }
-    if err := self.skipAllKey(); err != nil {
-        return nil, err
-    }
-    return self.toGenericObjectUsePair()
-}
+// func (self *Node) UnsafeMap() ([]Pair, error) {
+//     if err := self.should(types.V_OBJECT, "an object"); err != nil {
+//         return nil, err
+//     }
+//     if err := self.skipAllKey(); err != nil {
+//         return nil, err
+//     }
+//     return self.toGenericObjectUsePair()
+// }
 
 func (self *Node) unsafeMap() (*linkedPairs, error) {
     if err := self.should(types.V_OBJECT, "an object"); err != nil {
@@ -935,15 +935,15 @@ func (self *Node) ArrayUseNode() ([]Node, error) {
 //
 // Deprecated:  this API now returns copied nodes instead of directly reference, 
 // which has no difference with ArrayUseNode
-func (self *Node) UnsafeArray() ([]Node, error) {
-    if err := self.should(types.V_ARRAY, "an array"); err != nil {
-        return nil, err
-    }
-    if err := self.skipAllIndex(); err != nil {
-        return nil, err
-    }
-    return self.toGenericArrayUseNode()
-}
+// func (self *Node) UnsafeArray() ([]Node, error) {
+//     if err := self.should(types.V_ARRAY, "an array"); err != nil {
+//         return nil, err
+//     }
+//     if err := self.skipAllIndex(); err != nil {
+//         return nil, err
+//     }
+//     return self.toGenericArrayUseNode()
+// }
 
 func (self *Node) unsafeArray() (*linkedNodes, error) {
     if err := self.should(types.V_ARRAY, "an array"); err != nil {
diff --git a/ast/node_test.go b/ast/node_test.go
index ef24659d2..c6dce5332 100644
--- a/ast/node_test.go
+++ b/ast/node_test.go
@@ -690,44 +690,44 @@ func TestUnset(t *testing.T) {
 
 }
 
-func TestUnsafeNode(t *testing.T) {
-    str, loop := getTestIteratorSample(_DEFAULT_NODE_CAP)
-
-    root, err := NewSearcher(str).GetByPath("array")
-    if err != nil {
-        t.Fatal(err)
-    }
-    a, _ := root.UnsafeArray()
-    if len(a) != loop {
-        t.Fatalf("exp:%v, got:%v", loop, len(a))
-    }
-    for i := int64(0); i<int64(loop); i++{
-        in := a[i]
-        x, _ := in.Int64()
-        if x != i {
-            t.Fatalf("exp:%v, got:%v", i, x)
-        }
-    }
+// func TestUnsafeNode(t *testing.T) {
+//     str, loop := getTestIteratorSample(_DEFAULT_NODE_CAP)
+
+//     root, err := NewSearcher(str).GetByPath("array")
+//     if err != nil {
+//         t.Fatal(err)
+//     }
+//     a, _ := root.UnsafeArray()
+//     if len(a) != loop {
+//         t.Fatalf("exp:%v, got:%v", loop, len(a))
+//     }
+//     for i := int64(0); i<int64(loop); i++{
+//         in := a[i]
+//         x, _ := in.Int64()
+//         if x != i {
+//             t.Fatalf("exp:%v, got:%v", i, x)
+//         }
+//     }
     
-    root, err = NewSearcher(str).GetByPath("object")
-    if err != nil {
-        t.Fatal(err)
-    }
-    b, _ := root.UnsafeMap()
-    if len(b) != loop {
-        t.Fatalf("exp:%v, got:%v", loop, len(b))
-    }
-    for i := int64(0); i<int64(loop); i++ {
-        k := `k`+strconv.Itoa(int(i))
-        if k != b[i].Key {
-            t.Fatalf("unexpected element: %#v", b[i])
-        }
-        x, _ := b[i].Value.Int64()
-        if x != i {
-            t.Fatalf("exp:%v, got:%v", i, x)
-        }
-    }
-}
+//     root, err = NewSearcher(str).GetByPath("object")
+//     if err != nil {
+//         t.Fatal(err)
+//     }
+//     b, _ := root.UnsafeMap()
+//     if len(b) != loop {
+//         t.Fatalf("exp:%v, got:%v", loop, len(b))
+//     }
+//     for i := int64(0); i<int64(loop); i++ {
+//         k := `k`+strconv.Itoa(int(i))
+//         if k != b[i].Key {
+//             t.Fatalf("unexpected element: %#v", b[i])
+//         }
+//         x, _ := b[i].Value.Int64()
+//         if x != i {
+//             t.Fatalf("exp:%v, got:%v", i, x)
+//         }
+//     }
+// }
 
 func TestUseNode(t *testing.T) {
     str, loop := getTestIteratorSample(_DEFAULT_NODE_CAP)
diff --git a/ast/visitor_test.go b/ast/visitor_test.go
index a5f992697..9ecdc4a02 100644
--- a/ast/visitor_test.go
+++ b/ast/visitor_test.go
@@ -216,7 +216,9 @@ func (self *visitorNodeDiffTest) OnObjectEnd() error {
     require.NotNil(self.t, object)
 
     node := self.stk[self.sp-1].Node
-    pairs, err := node.UnsafeMap()
+    ps, err := node.unsafeMap()
+    var pairs = make([]Pair, ps.Len())
+    ps.ToSlice(pairs)
     require.NoError(self.t, err)
 
     keysGot := make([]string, 0, len(object))
@@ -267,8 +269,10 @@ func (self *visitorNodeDiffTest) OnArrayEnd() error {
     require.NotNil(self.t, array)
 
     node := self.stk[self.sp-1].Node
-    values, err := node.UnsafeArray()
+    vs, err := node.unsafeArray()
     require.NoError(self.t, err)
+    var values = make([]Node, vs.Len())
+    vs.ToSlice(values)
 
     require.EqualValues(self.t, len(values), len(array))
 
@@ -458,13 +462,14 @@ func (self *visitorUserNodeASTDecoder) decodeValue(root *Node) (visitorUserNode,
             value, ierr, ferr)
 
     case V_ARRAY:
-        nodes, err := root.UnsafeArray()
+        nodes, err := root.unsafeArray()
         if err != nil {
             return nil, err
         }
-        values := make([]visitorUserNode, len(nodes))
-        for i := range nodes {
-            value, err := self.decodeValue(&nodes[i])
+        values := make([]visitorUserNode, nodes.Len())
+        for i := 0; i<nodes.Len(); i++ {
+            n := nodes.At(i)
+            value, err := self.decodeValue(n)
             if err != nil {
                 return nil, err
             }
@@ -473,17 +478,17 @@ func (self *visitorUserNodeASTDecoder) decodeValue(root *Node) (visitorUserNode,
         return &visitorUserArray{Value: values}, nil
 
     case V_OBJECT:
-        pairs, err := root.UnsafeMap()
+        pairs, err := root.unsafeMap()
         if err != nil {
             return nil, err
         }
-        values := make(map[string]visitorUserNode, len(pairs))
-        for i := range pairs {
-            value, err := self.decodeValue(&pairs[i].Value)
+        values := make(map[string]visitorUserNode, pairs.Len())
+        for i := 0; i < pairs.Len(); i++ {
+            value, err := self.decodeValue(&pairs.At(i).Value)
             if err != nil {
                 return nil, err
             }
-            values[pairs[i].Key] = value
+            values[pairs.At(i).Key] = value
         }
         return &visitorUserObject{Value: values}, nil