Interesting. I actually thought that was valid Go. gccgo accepts it.

It should be valid Go. This is the current status of slice of bytes to string and string to slice of bytes conversions:

package main

type Byte byte

type Slicebyte []byte

type SliceByte []Byte

func main() {
	_ = string([]byte{})    // ok
	_ = string([]Byte{})    // internal error
	_ = string(Slicebyte{}) // ok
	_ = string(SliceByte{}) // internal error

	_ = []byte("")    // ok
	_ = []Byte("")    // ok
	_ = Slicebyte("") // ok
	_ = SliceByte("") // ok
}

I think this is specific to cmd/compile, gotype accept this program. You still get the error with -G=3 because we are still doing old typecheck after typechecking with types2.

Go spec allows:

type MyBytes []byte

var _ = string(MyBytes{'g', 'o'})

It's also consistent with conversion rule:

A non-constant value x can be converted to type T in any of these cases:
...
x is an integer or a slice of bytes or runes and T is a string type.

cc @mdempsky @griesemer @findleyr

Hmm, so the problem seems that cmd/compile also accept byte named type, but it generate the wrong code for base pointer to slice to pass to runtime function.

This program compile ok with cmd/compile:

package p

type Byte byte

var _ = string([]Byte{'f'})

Similar problem exists with slice or runes to string conversions

package main

type Rune rune

type SliceRune []Rune

func main() {
	_ = string([]Rune{})    // internal error
	_ = string(SliceRune{}) // internal error
}

./test.go:8:19: cannot use []Rune{} (type []Rune) as type []rune in argument to runtime.slicerunetostring
./test.go:9:22: cannot use SliceRune{} (type SliceRune) as type []rune in argument to runtime.slicerunetostring

But this time the error is in the call to runtime.slicerunetostring.

As for the slice of bytes, the error occurs only in function bodies.

@gazerro Yes, I think they have the same root cause, for either []Byte or []Rune, the compiler generate a base pointer node of the slice, with either *Byte or *Rune. This base pointer is passed to runtime functions, which expected it to be type *byte. Assigning *Byte to *byte is failed, because Byte and byte are distinct types.

In case of the global variables, the compiler don't generate code to runtime functions, that's why it's ok.

I think this violates the Go spec, since when []Byte is not a slice of bytes []byte.

@cuonglm I think this violates the Go spec, since when []Byte is not a slice of bytes.

In this case all these conversions should not be valid for Go spec

package p

type Byte byte
type SliceByte []Byte

var _ = []Byte("")
var _ = SliceByte("")
var _ = string([]Byte{})
var _ = string(SliceByte{})

Note that this program currently compiles.

Related: #23814.

@mdempsky Should we close this in favor of #23814?

@cuonglm Probably. I haven't read it too closely yet. If there's nothing new not covered by #23814 already, then closing it as a duplicate seems appropriate.

Closed as duplicated of #23814

@cuonglm the issue #23814 does not cover the internal error that occurs in the conversion. Could it be worth at least mentioning this error in issue #23814?

#23814 (comment)

(Also notably, cmd/compile's typechecker allows String(Bytes(nil)) and String(Runes(nil)), but then walk.go fails to generate the appropriate conversions when calling runtime.slicebytetostring and runtime.slicerunetostring, so compilation fails. It has a similar problem with the append call too.)