Go1.22

.github/workflows/ci.yml

@@ -21,18 +21,18 @@ jobs:
     name: Build
     strategy:
       matrix:
-        go-version: [1.21.x, 1.20.x]
+        go-version: [1.22.x, 1.21.x]
         platform: [ubuntu-20.04, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:
     - name: Install Go
-      uses: actions/setup-go@v4
+      uses: actions/setup-go@v5
       with:
         go-version: ${{ matrix.go-version }}
         cache: true
 
     - name: Cache-ROOT
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: ~/root-${{ env.ROOT_VERSION }}
         key: ${{ runner.os }}-root-${{ env.ROOT_VERSION }}
@@ -45,7 +45,7 @@ jobs:
         git config --global core.eol lf
 
     - name: Checkout code
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         fetch-depth: 1
 
@@ -94,7 +94,7 @@ jobs:
       with:
         install-go: false
         cache-key: ${{ matrix.platform }}
-        version: "2023.1.5"
+        version: "2023.1.6"
     - name: Upload-Coverage
       if: matrix.platform == 'ubuntu-20.04'
       uses: codecov/codecov-action@v3

go.mod

@@ -1,6 +1,6 @@
 module go-hep.org/x/hep
 
-go 1.20
+go 1.21
 
 require (
 	gioui.org v0.3.0

groot/gen.rtree.go

@@ -432,11 +432,7 @@ func (leaf *{{.Name}}) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *{{.Name}}) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / {{.GoLenType}}
-	arr := (*[0]{{.Type}})(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*{{.Type}})(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -585,7 +581,6 @@ func genRLeaves() {
 		Size  int
 		Kind  Kind
 		Func  string
-		Decay string
 		Count bool
 
 		WithStreamerElement bool // for TLeaf{F16,D32}
@@ -699,13 +694,6 @@ func genRLeaves() {
 				typ.Func = typ.Name
 			}
 
-			switch typ.Type[0] {
-			case 'u':
-				typ.Decay = "unsafeDecayArrayU"
-			default:
-				typ.Decay = "unsafeDecayArray"
-			}
-
 			tmpl := template.Must(template.New(typ.Name).Parse(rleafTmpl))
 			err = tmpl.Execute(f, typ)
 			if err != nil {
@@ -761,7 +749,7 @@ func newRLeaf{{.Name}}(leaf *{{.Base}}, rvar ReadVar, rctx rleafCtx) rleaf {
 			}
 			sli := reflect.ValueOf(rvar.Value).Elem()
 			ptr := (*[]{{.Type}})(unsafe.Pointer(sli.UnsafeAddr()))
-			hdr := unsafeDecaySliceArray{{.Name}}(ptr, sz).(*[]{{.Type}})
+			hdr := unsafeDecaySliceArray[{{.Type}}](ptr, sz)
 			if *hdr == nil {
 				*hdr = make([]{{.Type}}, 0, rleafDefaultSliceCap*sz)
 			}
@@ -770,16 +758,15 @@ func newRLeaf{{.Name}}(leaf *{{.Base}}, rvar ReadVar, rctx rleafCtx) rleaf {
 				n:    rctx.rcountFunc(leaf.count.Name()),
 				v:    hdr,
 			}
-			rawSli := (*reflect.SliceHeader)(unsafe.Pointer(sli.UnsafeAddr()))
-			rawHdr := (*reflect.SliceHeader)(unsafe.Pointer(hdr))
+			rhdr := reflect.ValueOf(hdr).Elem()
+			rptr := reflect.ValueOf(ptr).Elem()
 
 			// alias slices
-			rawSli.Data = rawHdr.Data
+			rptr.Set(rhdr)
 
 			rleaf.set = func() {
 				n := rleaf.n()
-				rawSli.Len = n
-				rawSli.Cap = n
+				rptr.SetLen(n)
 			}
 
 			return rleaf
@@ -788,7 +775,7 @@ func newRLeaf{{.Name}}(leaf *{{.Base}}, rvar ReadVar, rctx rleafCtx) rleaf {
 	case leaf.len > 1:
 		return &rleafArr{{.Name}}{
 			base: leaf,
-			v:    reflect.ValueOf(unsafeDecayArray{{.Name}}(rvar.Value)).Elem().Interface().([]{{.Type}}),
+			v:    *unsafeDecayArray[{{.Type}}](rvar.Value),
 		}
 
 	default:
@@ -812,28 +799,6 @@ func (leaf *rleaf{{.Kind}}{{.Name}}) ivalue() int { return int(*leaf.v) }
 {{- end}}
 {{- end}}
 
-{{if eq .Kind "Arr"}}
-func unsafeDecayArray{{.Name}}(ptr interface{}) interface{} {
-	rv := reflect.ValueOf(ptr).Elem()
-	sz := rv.Type().Size() / {{.Size}}
-	arr := (*[0]{{.Type}})(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
-	return &sli
-}
-
-func unsafeDecaySliceArray{{.Name}}(ptr *[]{{.Type}}, size int) interface{} {
-	var sli []{{.Type}}
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(size)
-	hdr.Cap = int(size)
-	hdr.Data = (*reflect.SliceHeader)(unsafe.Pointer(ptr)).Data
-	return &sli
-}
-{{- end}}
-
 {{if .WithStreamerElement}}
 func (leaf *rleaf{{.Kind}}{{.Name}}) readFromBuffer(r *rbytes.RBuffer) error {
 {{- if eq .Kind "Val" }}

groot/rtree/leaf_gen.go

@@ -132,11 +132,7 @@ func (leaf *LeafO) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafO) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 1
-	arr := (*[0]bool)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*bool)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -343,11 +339,7 @@ func (leaf *LeafB) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafB) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 1
-	arr := (*[0]int8)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int8)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -566,11 +558,7 @@ func (leaf *LeafS) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafS) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 2
-	arr := (*[0]int16)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int16)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -789,11 +777,7 @@ func (leaf *LeafI) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafI) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 4
-	arr := (*[0]int32)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int32)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -1012,11 +996,7 @@ func (leaf *LeafL) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafL) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]int64)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int64)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -1235,11 +1215,7 @@ func (leaf *LeafG) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafG) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]int64)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*int64)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -1438,11 +1414,7 @@ func (leaf *LeafF) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafF) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 4
-	arr := (*[0]float32)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*float32)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -1632,11 +1604,7 @@ func (leaf *LeafD) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafD) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]float64)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*float64)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -1837,11 +1805,7 @@ func (leaf *LeafF16) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafF16) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 4
-	arr := (*[0]root.Float16)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*root.Float16)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -2042,11 +2006,7 @@ func (leaf *LeafD32) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafD32) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 8
-	arr := (*[0]root.Double32)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*root.Double32)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 
@@ -2236,11 +2196,7 @@ func (leaf *LeafC) readFromBuffer(r *rbytes.RBuffer) error {
 func (leaf *LeafC) unsafeDecayArray(ptr interface{}) interface{} {
 	rv := reflect.ValueOf(ptr).Elem()
 	sz := rv.Type().Size() / 16
-	arr := (*[0]string)(unsafe.Pointer(rv.UnsafeAddr()))
-	sli := (*arr)[:]
-	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&sli))
-	hdr.Len = int(sz)
-	hdr.Cap = int(sz)
+	sli := unsafe.Slice((*string)(unsafe.Pointer(rv.UnsafeAddr())), sz)
 	return &sli
 }
 

groot/rtree/rleaf.go

@@ -344,3 +344,27 @@ func (l *rleafCount) imax() int {
 var (
 	_ leafCount = (*rleafCount)(nil)
 )
+
+// FIXME(sbinet): directly use reflect.TypeFor[T]().Size()
+// instead of this shim function.
+// (when Go >= 1.22)
+func sizeOfT[T any]() uintptr {
+	var t T
+	return reflect.TypeOf(t).Size()
+}
+
+func unsafeDecayArray[T any](ptr any) *[]T {
+	rv := reflect.ValueOf(ptr).Elem()
+	sz := rv.Type().Size() / sizeOfT[T]()
+	sli := unsafe.Slice((*T)(unsafe.Pointer(rv.UnsafeAddr())), sz)
+	return &sli
+}
+
+func unsafeDecaySliceArray[T any](ptr *[]T, size int) *[]T {
+	var sli []T
+	if *ptr == nil {
+		return &sli
+	}
+	sli = unsafe.Slice(unsafe.SliceData(*ptr), size)
+	return &sli
+}