// license that can be found in the LICENSE file.

// Test case where a slice of a user-defined byte type (not uint8 or byte) is
// converted to a string.  Same for slice of runes.

package main

type MyByte byte

type MyRune rune

func f[T []MyByte](x T) string {
	return string(x)
}

func g[T []MyRune](x T) string {
	return string(x)
}

func main() {
	var y []MyByte
	_ = f(y)

//
//	q := strconv.Quote("Hello, 世界")
//	q := strconv.QuoteToASCII("Hello, 世界")
//
// [QuoteRune] and [QuoteRuneToASCII] are similar but accept runes and
// return quoted Go rune literals.
//
// [Unquote] and [UnquoteChar] unquote Go string and rune literals.

// license that can be found in the LICENSE file.

// Test case where a slice of a user-defined byte type (not uint8 or byte) is
// converted to a string.  Same for slice of runes.

package main

type MyByte byte

type MyRune rune

func main() {
	var y []MyByte
	_ = string(y)

	var z []MyRune
	_ = string(z)

	r = -1
	s = string(r)
	assert(s, "\xef\xbf\xbd", "negative rune")

	// the large rune tests again, this time using constants instead of a variable.
	// these conversions will be done at compile time.
	s = string(0x10ffff) // largest rune value
	assert(s, "\xf4\x8f\xbf\xbf", "largest rune constant")
	s = string(0x10ffff + 1)
	assert(s, "\xef\xbf\xbd", "too-large rune constant")
	s = string(0xD800)

	hicb = 0xBF // 1011 1111
)

// countrunes returns the number of runes in s.
func countrunes(s string) int {
	n := 0
	for range s {
		n++
	}
	return n
}

// decoderune returns the non-ASCII rune at the start of
// s[k:] and the index after the rune in s.
//
// decoderune assumes that caller has checked that
// the to be decoded rune is a non-ASCII rune.
//
// If the string appears to be incomplete or decoding problems

Jonh Wendell <******@****.***> 1715709579 -0400

Jonh Wendell <******@****.***> 1715709579 -0400

func Decode(s []uint16) []rune {
	// Preallocate capacity to hold up to 64 runes.
	// Decode inlines, so the allocation can live on the stack.
	buf := make([]rune, 0, 64)
	return decode(s, buf)
}

// decode appends to buf the Unicode code point sequence represented
// by the UTF-16 encoding s and return the extended buffer.
func decode(s []uint16, buf []rune) []rune {
	for i := 0; i < len(s); i++ {

}

// "x is a string and T is a slice of bytes or runes"

func _[T ~[]byte](x string) T { return T(x) }
func _[T ~[]rune](x string) T { return T(x) }
func _[T ~[]rune](x *string) T {
	return T(x /* ERROR "cannot convert x (variable of type *string) to type T: cannot convert *string to type []rune (in T)" */)
}

package p

import "unsafe"

const C = 1

var x, x1, x2 int
var b bool
var s string
var c chan int
var cp complex128
var slice []int
var array [2]int
var bytes []byte
var runes []rune
var r rune

func f0()            {}
func f1() int        { return 1 }
func f2() (int, int) { return 1, 1 }

type T struct{ X int }

func (T) M1() int { return 1 }
func (T) M0()     {}
func (T) M()      {}