Break Change: drop ast.Node API UnsafeArray() and UnsafeMap() (bytedance#498)

Author: AsterDY

.github/workflows/compatibility_test-windows.yml

@@ -6,7 +6,7 @@ jobs:
   build:
     strategy:
       matrix:
-        go-version: [1.17.x, 1.20.x]
+        go-version: [1.17.x, 1.21.x]
     runs-on: windows-latest
     steps:
       - uses: actions/checkout@v2

.github/workflows/compatibility_test.yml

@@ -6,7 +6,7 @@ jobs:
   build:
     strategy:
       matrix:
-        go-version: [1.15.x, 1.16.x, 1.17.x, 1.18.x, 1.19.x, 1.20.x]
+        go-version: [1.15.x, 1.16.x, 1.17.x, 1.18.x, 1.19.x, 1.20.x, 1.21.x]
         os: [arm, X64]
     runs-on: ${{ matrix.os }}
     steps:

.github/workflows/unit_test-linux-x64.yml

@@ -6,7 +6,7 @@ jobs:
   build:
     strategy:
       matrix:
-        go-version: [1.16.x, 1.17.x, 1.18.x, 1.19.x, 1.20.x]
+        go-version: [1.16.x, 1.17.x, 1.18.x, 1.19.x, 1.20.x, 1.21.x]
     runs-on: [self-hosted, X64]
     steps:
       - name: Clear repository

README.md

@@ -5,7 +5,7 @@ English | [中文](README_ZH_CN.md)
 A blazingly fast JSON serializing & deserializing library, accelerated by JIT (just-in-time compiling) and SIMD (single-instruction-multiple-data).
 
 ## Requirement
-- Go 1.16~1.20
+- Go 1.16~1.21
 - Linux / MacOS / Windows(need go1.17 above)
 - Amd64 ARCH
 

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 {

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)

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
 

.github/workflows/go_latest_test.yml scripts/go_latest_test.yml

@@ -25,4 +25,5 @@ jobs:
 
       - name: script
         run: |
-          sh ./scripts/go_latest.sh go1.21.0
+          sh ./scripts/go_latest.sh master
+