Merge pull request gopherjs#1120 from nevkontakte/go1.18

Various standard library and compiler fixes to support Go 1.18

Author: nevkontakte

.std_test_pkg_exclusions

@@ -1,8 +1,10 @@
 embed/internal/embedtest
+encoding/xml
 go/build
 go/internal/srcimporter
 go/types
 internal/abi
+internal/intern
 internal/syscall/windows
 internal/syscall/windows/registry
 internal/syscall/windows/sysdll

compiler/gopherjspkg/fs_vfsdata.go

@@ -0,0 +1,29 @@
+//go:build js
+
+package intern
+
+var (
+	eth0 = &Value{cmpVal: "eth0"}
+	eth1 = &Value{cmpVal: "eth1"}
+)
+
+func get(k key) *Value {
+	// Interning implementation in this package unavoidably relies upon
+	// runtime.SetFinalizer(), which GopherJS doesn't support (at least until it
+	// is considered safe to use the WeakMap API). Without working finalizers
+	// using this package would create memory leaks.
+	//
+	// Considering that this package is supposed to serve as an optimization tool,
+	// it is better to make it explicitly unusable and work around it at the call
+	// sites.
+
+	// net/netip tests use intern API with a few fixed values. It is easier to
+	// special-case them here than to override the entire test set.
+	if k.isString && k.s == "eth0" {
+		return eth0
+	} else if k.isString && k.s == "eth1" {
+		return eth1
+	}
+
+	panic("internal/intern is not supported by GopherJS")
+}

compiler/natives/fs_vfsdata.go

@@ -11,7 +11,12 @@ var math = js.Global.Get("Math")
 var _zero float64 = 0
 var posInf = 1 / _zero
 var negInf = -1 / _zero
-var nan = 0 / _zero
+
+// Usually, NaN can be obtained in JavaScript with `0 / 0` operation. However,
+// in V8, `0 / _zero` yields a bitwise-different value of NaN compared to the
+// default NaN or `0 / 0`. Unfortunately, Go compiler forbids division by zero,
+// so we have to get this value from prelude.
+var nan = js.Global.Get("$NaN").Float()
 
 func Acos(x float64) float64 {
 	return math.Call("acos", x).Float()

compiler/natives/src/internal/intern/intern.go

@@ -11,6 +11,6 @@ func init() {
 	// TODO(nevkontakte): We could test our real implementations if we mock out
 	// browser APIs and redirect them to the fake networking stack, but this is
 	// not easy.
-	useFakeNetwork = true
+	jsFetchMissing = true
 	DefaultTransport = &Transport{}
 }

compiler/natives/src/math/math.go

@@ -0,0 +1,20 @@
+//go:build js
+
+package netip
+
+import (
+	"fmt"
+	"internal/intern"
+)
+
+//gopherjs:prune-original
+func MkAddr(u Uint128, z any) Addr {
+	switch z := z.(type) {
+	case *intern.Value:
+		return Addr{u, z.Get().(string)}
+	case string:
+		return Addr{u, z}
+	default:
+		panic(fmt.Errorf("unexpected type %T of the z argument"))
+	}
+}

compiler/natives/src/net/http/http_wasm_test.go

@@ -0,0 +1,39 @@
+//go:build js
+
+package netip
+
+type Addr struct {
+	addr uint128
+	// Unlike the upstream, we store the string directly instead of trying to
+	// use internal/intern package for optimization.
+	z string
+}
+
+var (
+	// Sentinel values for different zones. \x00 character makes it unlikely for
+	// the sentinel value to clash with any real-life IPv6 zone index.
+	z0    = ""
+	z4    = "\x00ipv4"
+	z6noz = "\x00ipv6noz"
+)
+
+//gopherjs:prune-original
+func (ip Addr) Zone() string {
+	if ip.z == z4 || ip.z == z6noz {
+		return ""
+	}
+	return ip.z
+}
+
+//gopherjs:prune-original
+func (ip Addr) WithZone(zone string) Addr {
+	if !ip.Is6() {
+		return ip
+	}
+	if zone == "" {
+		ip.z = z6noz
+		return ip
+	}
+	ip.z = zone
+	return ip
+}

compiler/natives/src/net/netip/export_test.go

@@ -660,6 +660,25 @@ func mapdelete(t *rtype, m unsafe.Pointer, key unsafe.Pointer) {
 	js.InternalObject(m).Delete(k)
 }
 
+// TODO(nevkonatkte): The following three "faststr" implementations are meant to
+// perform better for the common case of string-keyed maps (see upstream:
+// https://github.com/golang/go/commit/23832ba2e2fb396cda1dacf3e8afcb38ec36dcba)
+// However, the stubs below will perform the same or worse because of the extra
+// string-to-pointer conversion. Not sure how to fix this without significant
+// code duplication, however.
+
+func mapaccess_faststr(t *rtype, m unsafe.Pointer, key string) (val unsafe.Pointer) {
+	return mapaccess(t, m, unsafe.Pointer(&key))
+}
+
+func mapassign_faststr(t *rtype, m unsafe.Pointer, key string, val unsafe.Pointer) {
+	mapassign(t, m, unsafe.Pointer(&key), val)
+}
+
+func mapdelete_faststr(t *rtype, m unsafe.Pointer, key string) {
+	mapdelete(t, m, unsafe.Pointer(&key))
+}
+
 type hiter struct {
 	t    Type
 	m    *js.Object // Underlying map object.

compiler/natives/src/net/netip/netip.go

@@ -66,3 +66,10 @@ func (b *Builder) copyCheck() {
 		panic("strings: illegal use of non-zero Builder copied by value")
 	}
 }
+
+func Clone(s string) string {
+	// Since in the JavaScript runtime we don't have access the the string's
+	// baking memory, we let the engine's garbage collector deal with substring
+	// memory overheads and simply return the string as-is.
+	return s
+}