internal/reflectlite: do not use the reflect package

This avoids a dependency on the reflect package.

I've tried to deduplicate as much as reasonably possible, while keeping
the code clean. Especially some tricky methods for the reflect.Type type
have a shared implementation (using //go:linkname). In other cases, I've
simply used the same type using a type alias, in the other direction
(the reflect package now imports the internal/reflectlite package).

Author: aykevl

src/internal/reflectlite/error.go

@@ -0,0 +1,25 @@
+package reflectlite
+
+type TypeError struct {
+	Method string
+}
+
+func (e *TypeError) Error() string {
+	return "reflect: call of reflect.Type." + e.Method + " on invalid type"
+}
+
+var (
+	errTypeElem = &TypeError{"Elem"}
+)
+
+type ValueError struct {
+	Method string
+	Kind   Kind
+}
+
+func (e *ValueError) Error() string {
+	if e.Kind == 0 {
+		return "reflect: call of " + e.Method + " on zero Value"
+	}
+	return "reflect: call of " + e.Method + " on " + e.Kind.String() + " Value"
+}

src/internal/reflectlite/reflect.go

@@ -0,0 +1,40 @@
+package reflectlite
+
+import "unsafe"
+
+// Some of code here has been copied from the Go sources:
+//   https://github.com/golang/go/blob/go1.15.2/src/reflect/swapper.go
+// It has the following copyright note:
+//
+// 		Copyright 2016 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.
+
+func Swapper(slice interface{}) func(i, j int) {
+	v := ValueOf(slice)
+	if v.Kind() != Slice {
+		panic(&ValueError{Method: "Swapper"})
+	}
+
+	// Just return Nop func if nothing to swap.
+	if v.Len() < 2 {
+		return func(i, j int) {}
+	}
+
+	typ := v.typecode.Elem()
+	size := typ.Size()
+
+	header := (*sliceHeader)(v.value)
+	tmp := unsafe.Pointer(&make([]byte, size)[0])
+
+	return func(i, j int) {
+		if uint(i) >= uint(header.len) || uint(j) >= uint(header.len) {
+			panic("reflect: slice index out of range")
+		}
+		val1 := unsafe.Add(header.data, uintptr(i)*size)
+		val2 := unsafe.Add(header.data, uintptr(j)*size)
+		memcpy(tmp, val1, size)
+		memcpy(val1, val2, size)
+		memcpy(val2, tmp, size)
+	}
+}