Remove compatibility code for Go versions prior to 1.20

Author: nekohasekai

common/atomic/typed.go

@@ -6,45 +6,41 @@ import (
 	"github.com/sagernet/sing/common"
 )
 
-type TypedValue[T any] struct {
-	value atomic.Value
-}
-
-// typedValue is a struct with determined type to resolve atomic.Value usages with interface types
-// https://github.com/golang/go/issues/22550
-//
-// The intention to have an atomic value store for errors. However, running this code panics:
-// panic: sync/atomic: store of inconsistently typed value into Value
-// This is because atomic.Value requires that the underlying concrete type be the same (which is a reasonable expectation for its implementation).
-// When going through the atomic.Value.Store method call, the fact that both these are of the error interface is lost.
-type typedValue[T any] struct {
-	value T
-}
+type TypedValue[T any] atomic.Pointer[T]
 
 func (t *TypedValue[T]) Load() T {
-	value := t.value.Load()
+	value := (*atomic.Pointer[T])(t).Load()
 	if value == nil {
 		return common.DefaultValue[T]()
 	}
-	return value.(typedValue[T]).value
+	return *value
 }
 
 func (t *TypedValue[T]) Store(value T) {
-	t.value.Store(typedValue[T]{value})
+	(*atomic.Pointer[T])(t).Store(&value)
 }
 
 func (t *TypedValue[T]) Swap(new T) T {
-	old := t.value.Swap(typedValue[T]{new})
+	old := (*atomic.Pointer[T])(t).Swap(&new)
 	if old == nil {
 		return common.DefaultValue[T]()
 	}
-	return old.(typedValue[T]).value
+	return *old
 }
 
 func (t *TypedValue[T]) CompareAndSwap(old, new T) bool {
-	return t.value.CompareAndSwap(typedValue[T]{old}, typedValue[T]{new}) ||
-		// In the edge-case where [atomic.Value.Store] is uninitialized
-		// and trying to compare with the zero value of T,
-		// then compare-and-swap with the nil any value.
-		(any(old) == any(common.DefaultValue[T]()) && t.value.CompareAndSwap(any(nil), typedValue[T]{new}))
+	for {
+		currentP := (*atomic.Pointer[T])(t).Load()
+		currentValue := common.DefaultValue[T]()
+		if currentP != nil {
+			currentValue = *currentP
+		}
+		// Compare old and current via runtime equality check.
+		if any(currentValue) != any(old) {
+			return false
+		}
+		if (*atomic.Pointer[T])(t).CompareAndSwap(currentP, &new) {
+			return true
+		}
+	}
 }

common/atomic/types.go

@@ -1,19 +1,20 @@
-//go:build go1.19
+//go:build go1.24
 
 package atomic
 
 import "sync/atomic"
 
 type (
-	Bool    = atomic.Bool
-	Int32   = atomic.Int32
-	Int64   = atomic.Int64
-	Uint32  = atomic.Uint32
-	Uint64  = atomic.Uint64
-	Uintptr = atomic.Uintptr
-	Value   = atomic.Value
+	Bool           = atomic.Bool
+	Int32          = atomic.Int32
+	Int64          = atomic.Int64
+	Uint32         = atomic.Uint32
+	Uint64         = atomic.Uint64
+	Uintptr        = atomic.Uintptr
+	Value          = atomic.Value
+	Pointer[T any] = atomic.Pointer[T]
 )
 
-type Pointer[T any] struct {
-	atomic.Pointer[T]
+func PointerForm[T any](p *atomic.Pointer[T]) *Pointer[T] {
+	return p
 }

common/atomic/types_compat.go

@@ -1,198 +1,23 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build !go1.19
+//go:build !go1.24
 
 package atomic
 
-import (
-	"sync/atomic"
-	"unsafe"
-)
-
-// A Bool is an atomic boolean value.
-// The zero value is false.
-type Bool struct {
-	_ noCopy
-	v uint32
-}
-
-// Load atomically loads and returns the value stored in x.
-func (x *Bool) Load() bool { return atomic.LoadUint32(&x.v) != 0 }
-
-// Store atomically stores val into x.
-func (x *Bool) Store(val bool) { atomic.StoreUint32(&x.v, b32(val)) }
+import "sync/atomic"
 
-// Swap atomically stores new into x and returns the previous value.
-func (x *Bool) Swap(new bool) (old bool) { return atomic.SwapUint32(&x.v, b32(new)) != 0 }
-
-// CompareAndSwap executes the compare-and-swap operation for the boolean value x.
-func (x *Bool) CompareAndSwap(old, new bool) (swapped bool) {
-	return atomic.CompareAndSwapUint32(&x.v, b32(old), b32(new))
-}
-
-// b32 returns a uint32 0 or 1 representing b.
-func b32(b bool) uint32 {
-	if b {
-		return 1
-	}
-	return 0
-}
+type (
+	Bool    = atomic.Bool
+	Int32   = atomic.Int32
+	Int64   = atomic.Int64
+	Uint32  = atomic.Uint32
+	Uint64  = atomic.Uint64
+	Uintptr = atomic.Uintptr
+	Value   = atomic.Value
+)
 
-// A Pointer is an atomic pointer of type *T. The zero value is a nil *T.
 type Pointer[T any] struct {
-	// Mention *T in a field to disallow conversion between Pointer types.
-	// See go.dev/issue/56603 for more details.
-	// Use *T, not T, to avoid spurious recursive type definition errors.
-	_ [0]*T
-
-	_ noCopy
-	v unsafe.Pointer
-}
-
-// Load atomically loads and returns the value stored in x.
-func (x *Pointer[T]) Load() *T { return (*T)(atomic.LoadPointer(&x.v)) }
-
-// Store atomically stores val into x.
-func (x *Pointer[T]) Store(val *T) { atomic.StorePointer(&x.v, unsafe.Pointer(val)) }
-
-// Swap atomically stores new into x and returns the previous value.
-func (x *Pointer[T]) Swap(new *T) (old *T) {
-	return (*T)(atomic.SwapPointer(&x.v, unsafe.Pointer(new)))
-}
-
-// CompareAndSwap executes the compare-and-swap operation for x.
-func (x *Pointer[T]) CompareAndSwap(old, new *T) (swapped bool) {
-	return atomic.CompareAndSwapPointer(&x.v, unsafe.Pointer(old), unsafe.Pointer(new))
-}
-
-// An Int32 is an atomic int32. The zero value is zero.
-type Int32 struct {
-	_ noCopy
-	v int32
+	*atomic.Pointer[T]
 }
 
-// Load atomically loads and returns the value stored in x.
-func (x *Int32) Load() int32 { return atomic.LoadInt32(&x.v) }
-
-// Store atomically stores val into x.
-func (x *Int32) Store(val int32) { atomic.StoreInt32(&x.v, val) }
-
-// Swap atomically stores new into x and returns the previous value.
-func (x *Int32) Swap(new int32) (old int32) { return atomic.SwapInt32(&x.v, new) }
-
-// CompareAndSwap executes the compare-and-swap operation for x.
-func (x *Int32) CompareAndSwap(old, new int32) (swapped bool) {
-	return atomic.CompareAndSwapInt32(&x.v, old, new)
+func PointerForm[T any](p *atomic.Pointer[T]) *Pointer[T] {
+	return &Pointer[T]{p}
 }
-
-// Add atomically adds delta to x and returns the new value.
-func (x *Int32) Add(delta int32) (new int32) { return atomic.AddInt32(&x.v, delta) }
-
-// An Int64 is an atomic int64. The zero value is zero.
-type Int64 struct {
-	_ noCopy
-	v int64
-}
-
-// Load atomically loads and returns the value stored in x.
-func (x *Int64) Load() int64 { return atomic.LoadInt64(&x.v) }
-
-// Store atomically stores val into x.
-func (x *Int64) Store(val int64) { atomic.StoreInt64(&x.v, val) }
-
-// Swap atomically stores new into x and returns the previous value.
-func (x *Int64) Swap(new int64) (old int64) { return atomic.SwapInt64(&x.v, new) }
-
-// CompareAndSwap executes the compare-and-swap operation for x.
-func (x *Int64) CompareAndSwap(old, new int64) (swapped bool) {
-	return atomic.CompareAndSwapInt64(&x.v, old, new)
-}
-
-// Add atomically adds delta to x and returns the new value.
-func (x *Int64) Add(delta int64) (new int64) { return atomic.AddInt64(&x.v, delta) }
-
-// An Uint32 is an atomic uint32. The zero value is zero.
-type Uint32 struct {
-	_ noCopy
-	v uint32
-}
-
-// Load atomically loads and returns the value stored in x.
-func (x *Uint32) Load() uint32 { return atomic.LoadUint32(&x.v) }
-
-// Store atomically stores val into x.
-func (x *Uint32) Store(val uint32) { atomic.StoreUint32(&x.v, val) }
-
-// Swap atomically stores new into x and returns the previous value.
-func (x *Uint32) Swap(new uint32) (old uint32) { return atomic.SwapUint32(&x.v, new) }
-
-// CompareAndSwap executes the compare-and-swap operation for x.
-func (x *Uint32) CompareAndSwap(old, new uint32) (swapped bool) {
-	return atomic.CompareAndSwapUint32(&x.v, old, new)
-}
-
-// Add atomically adds delta to x and returns the new value.
-func (x *Uint32) Add(delta uint32) (new uint32) { return atomic.AddUint32(&x.v, delta) }
-
-// An Uint64 is an atomic uint64. The zero value is zero.
-type Uint64 struct {
-	_ noCopy
-	v uint64
-}
-
-// Load atomically loads and returns the value stored in x.
-func (x *Uint64) Load() uint64 { return atomic.LoadUint64(&x.v) }
-
-// Store atomically stores val into x.
-func (x *Uint64) Store(val uint64) { atomic.StoreUint64(&x.v, val) }
-
-// Swap atomically stores new into x and returns the previous value.
-func (x *Uint64) Swap(new uint64) (old uint64) { return atomic.SwapUint64(&x.v, new) }
-
-// CompareAndSwap executes the compare-and-swap operation for x.
-func (x *Uint64) CompareAndSwap(old, new uint64) (swapped bool) {
-	return atomic.CompareAndSwapUint64(&x.v, old, new)
-}
-
-// Add atomically adds delta to x and returns the new value.
-func (x *Uint64) Add(delta uint64) (new uint64) { return atomic.AddUint64(&x.v, delta) }
-
-// An Uintptr is an atomic uintptr. The zero value is zero.
-type Uintptr struct {
-	_ noCopy
-	v uintptr
-}
-
-// Load atomically loads and returns the value stored in x.
-func (x *Uintptr) Load() uintptr { return atomic.LoadUintptr(&x.v) }
-
-// Store atomically stores val into x.
-func (x *Uintptr) Store(val uintptr) { atomic.StoreUintptr(&x.v, val) }
-
-// Swap atomically stores new into x and returns the previous value.
-func (x *Uintptr) Swap(new uintptr) (old uintptr) { return atomic.SwapUintptr(&x.v, new) }
-
-// CompareAndSwap executes the compare-and-swap operation for x.
-func (x *Uintptr) CompareAndSwap(old, new uintptr) (swapped bool) {
-	return atomic.CompareAndSwapUintptr(&x.v, old, new)
-}
-
-// Add atomically adds delta to x and returns the new value.
-func (x *Uintptr) Add(delta uintptr) (new uintptr) { return atomic.AddUintptr(&x.v, delta) }
-
-// noCopy may be added to structs which must not be copied
-// after the first use.
-//
-// See https://golang.org/issues/8005#issuecomment-190753527
-// for details.
-//
-// Note that it must not be embedded, due to the Lock and Unlock methods.
-type noCopy struct{}
-
-// Lock is a no-op used by -copylocks checker from `go vet`.
-func (*noCopy) Lock()   {}
-func (*noCopy) Unlock() {}
-
-type Value = atomic.Value

common/control/protect_other.go

@@ -1,4 +1,4 @@
-//go:build (go1.19 && !unix) || (!go1.19 && !(linux || darwin))
+//go:build !unix
 
 package control
 

common/control/protect_unix.go

@@ -1,4 +1,4 @@
-//go:build (go1.19 && unix) || (!go1.19 && (linux || darwin))
+//go:build unix
 
 package control