Preserve nil slices when converting between different slice types.

nevkontakte · nevkontakte · commit 9a879c256d93 · 2021-08-25T21:06:32.000+01:00
Prior to this change the following would evaluate to false:

```
type mySlice []byte
_ = mySlice([]byte(nil)) == nil // Got: false, want: true
```

The fix is to check during conversion whether a slice is a nil slice and
return nil slice of the desired type in that case. GopherJS uses
sentinel values for nil slices, and technically they are are just
regular zero-length slices.
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -1154,7 +1154,7 @@ func (fc *funcContext) translateImplicitConversion(expr ast.Expr, desiredType ty
 
 	switch desiredType.Underlying().(type) {
 	case *types.Slice:
-		return fc.formatExpr("$subslice(new %1s(%2e.$array), %2e.$offset, %2e.$offset + %2e.$length)", fc.typeName(desiredType), expr)
+		return fc.formatExpr("$convertSliceType(%1e, %2s)", expr, fc.typeName(desiredType))
 
 	case *types.Interface:
 		if typesutil.IsJsObject(exprType) {
diff --git a/compiler/prelude/prelude.go b/compiler/prelude/prelude.go
@@ -180,6 +180,15 @@ var $sliceToGoArray = function(slice, arrayPtrType) {
   $throwRuntimeError("gopherjs: non-numeric slice to underlying array conversion is not supported for subslices");
 };
 
+// Convert between compatible slice types (e.g. native and names).
+var $convertSliceType = function(slice, desiredType) {
+  if (slice == slice.constructor.nil) {
+    return desiredType.nil; // Preserve nil value.
+  }
+
+  return $subslice(new desiredType(slice.$array), slice.$offset, slice.$offset + slice.$length);
+}
+
 var $decodeRune = function(str, pos) {
   var c0 = str.charCodeAt(pos);
 
diff --git a/compiler/prelude/prelude_min.go b/compiler/prelude/prelude_min.go
diff --git a/tests/misc_test.go b/tests/misc_test.go
@@ -666,6 +666,25 @@ func TestSlicingNilSlice(t *testing.T) {
 	})
 }
 
+func TestConvertingNilSlice(t *testing.T) {
+	type mySlice []byte
+
+	a := []byte(nil)
+	if a != nil {
+		t.Errorf("[]byte(nil) != nil")
+	}
+
+	b := mySlice(a)
+	if b != nil {
+		t.Errorf("mySlice([]byte(nil)) != nil")
+	}
+
+	c := mySlice(nil)
+	if c != nil {
+		t.Errorf("mySlice(nil) != nil")
+	}
+}
+
 // Ensure that doing an interface conversion that fails
 // produces an expected error type with the right error text.
 func TestInterfaceConversionRuntimeError(t *testing.T) {
