{"ASCII", "01234567890"},
	{"Japanese", "日本語日本語日本語"},
	{"MixedLength", "$Ѐࠀက퀀𐀀\U00040000\U0010FFFF"},
}

var sinkInt int

func BenchmarkRuneCount(b *testing.B) {
	// Each sub-benchmark counts the runes in a string in a different way.
	b.Run("lenruneslice", func(b *testing.B) {
		for _, sd := range stringdata {
			b.Run(sd.name, func(b *testing.B) {
				for i := 0; i < b.N; i++ {
					sinkInt += len([]rune(sd.data))

		w.rb.src = inputBytes(data[:m])
		w.rb.nsrc = m
		w.buf = doAppend(&w.rb, w.buf, 0)
		data = data[m:]
		n += m

		// Write out complete prefix, save remainder.
		// Note that lastBoundary looks back at most 31 runes.
		i := lastBoundary(&w.rb.f, w.buf)
		if i == -1 {
			i = 0
		}
		if i > 0 {
			if _, err = w.w.Write(w.buf[:i]); err != nil {
				break
			}
			bn := copy(w.buf, w.buf[i:])
			w.buf = w.buf[:bn]
		}

// encodeWTF16 returns the potentially ill-formed
// UTF-16 encoding of s.
func encodeWTF16(s string, buf []uint16) []uint16 {
	for i := 0; i < len(s); {
		// Cannot use 'for range s' because it expects valid
		// UTF-8 runes.
		r, size := utf8.DecodeRuneInString(s[i:])
		if r == utf8.RuneError {
			// Check if s[i:] contains a valid WTF-8 encoded surrogate.

	return T(x /* ERROR "cannot convert x (variable of type X constrained by Float | Complex) to type T: cannot convert float32 (in X) to type complex64 (in T)" */)
}

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

type myInt int
type myString string

func _[T ~string](x int) T      { return T(x) }
func _[T ~string](x myInt) T    { return T(x) }
func _[X Integer](x X) string   { return string(x) }

// TODO(rfindley): this should not be necessary.
func sanitizeObjectString(s string) string {
	var runes []rune
	for _, r := range s {
		if '₀' <= r && r < '₀'+10 {
			continue // trim type parameter subscripts
		}
		runes = append(runes, r)
	}
	return string(runes)
}

func checkFile(t *testing.T, filename string, src []byte) *types.Package {
	fset := token.NewFileSet()

// If the index refers to a sequence of elements
//
//	[Plain("["), Plain_or_Code(text), Plain("]")]
//
// and the brackets are adjacent to the right kind of runes for a link, then
// symbolLinkText returns the text of the middle element.
// Otherwise it returns the empty string.
func symbolLinkText(i int, ins []md.Inline) string {

	// is always non-zero if different from info.ccc and that we can return
	// false at this point. This is verified by maketables.
	return false
}

// BoundaryAfter returns true if runes cannot combine with or otherwise
// interact with this or previous runes.
func (p Properties) BoundaryAfter() bool {
	// TODO: loosen these conditions.
	return p.isInert()
}

// We pack quick check data in 4 bits:
//

	recorded map[string]bool

	// ordered tracks warnings added so they can be replayed and truncated if needed
	ordered []recordedWarning

	// written tracks how many runes of text have been added as warning headers
	written int

	// truncating tracks if we have already exceeded truncateAtTotalRunes and are now truncating warning messages as we add them
	truncating bool

	if isComplex(Vu) && isComplex(Tu) {
		return true
	}

	// "V is an integer or a slice of bytes or runes and T is a string type"
	if (isInteger(Vu) || isBytesOrRunes(Vu)) && isString(Tu) {
		return true
	}

	// "V is a string and T is a slice of bytes or runes"
	if isString(Vu) && isBytesOrRunes(Tu) {
		return true
	}

	// package unsafe:

		t.Errorf("expected\n%#v\ngot\n%#v", e, a)
	}
	// add an item that exceeds the length and triggers truncation, reducing existing items to 15 runes
	warningRecorder.AddWarning("", "e")          // triggering item, 16 total
	warningRecorder.AddWarning("", "ffffffffff") // long item to get truncated, 21 total
	warningRecorder.AddWarning("", "ffffffffff") // duplicate item