// f.Sensitive is false and indexing is true, "Incremental Indexing"
// representation is used.
func appendIndexedName(dst []byte, f HeaderField, i uint64, indexing bool) []byte {
	first := len(dst)
	var n byte
	if indexing {
		n = 6
	} else {
		n = 4
	}
	dst = appendVarInt(dst, n, i)
	dst[first] |= encodeTypeByte(indexing, f.Sensitive)
	return appendHpackString(dst, f.Value)
}

                    languageFeature = Indexing,
                    potentialElementSource = indexes: 0..4, line/column: 1/1..1/5, file: test,
                    erroneousSource = indexes: 0..4, line/column: 1/1..1/5, file: test
                )
            )
            ErroneousStatement (
                UnsupportedConstruct(
                    languageFeature = Indexing,

// run

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Testing various generic uses of indexing, both for reads and writes.

package main

import "fmt"

// Can index an argument (read/write) constrained to be a slice or an array.
func Index1[T interface{ []int64 | [5]int64 }](x T) int64 {
	x[2] = 5
	return x[3]
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package http

import "math"

// A routingIndex optimizes conflict detection by indexing patterns.
//
// The basic idea is to rule out patterns that cannot conflict with a given
// pattern because they have a different literal in a corresponding segment.

package http

import (
	"fmt"
	"slices"
	"strings"
	"testing"
)

func TestIndex(t *testing.T) {
	// Generate every kind of pattern up to some number of segments,
	// and compare conflicts found during indexing with those found
	// by exhaustive comparison.
	patterns := generatePatterns()
	var idx routingIndex
	for i, pat := range patterns {
		got := indexConflicts(pat, &idx)
		want := trueConflicts(pat, patterns[:i])

func foo(d *decimal) int {
	exp := int(d.d[1])
	if d.dp < 0 || d.dp == 0 && d.d[0] < '5' {
		var n int
		if -d.dp >= len(powtab) {
			n = 27
		} else {
			n = powtab[-d.dp] // incorrect CMP -> CMN substitution causes indexing panic.
		}
		exp += n
	}
	return exp
}

func main() {
	var d decimal
	d.d[0] = '1'
	if foo(&d) != 1 {
		println("FAILURE (though not the one this test was written to catch)")
	}

import com.intellij.psi.PsiManager
import com.intellij.psi.SingleRootFileViewProvider
import com.intellij.psi.search.GlobalSearchScope
import com.intellij.psi.stubs.StubElement
import com.intellij.util.indexing.FileContent
import com.intellij.util.indexing.FileContentImpl
import org.jetbrains.kotlin.analysis.decompiler.konan.K2KotlinNativeMetadataDecompiler
import org.jetbrains.kotlin.analysis.decompiler.konan.KlibMetaFileType

labels.excludedUrls=Excluded URLs For Crawling
labels.excludedDocPaths=Excluded Paths For Indexing
labels.excludedDocUrls=Excluded URLs For Indexing
labels.hostname=Hostname
labels.id=ID
labels.includedPaths=Included Paths For Crawling
labels.includedUrls=Included URLs For Crawling
labels.includedDocPaths=Included Paths For Indexing
labels.includedDocUrls=Included URLs For Indexing
labels.maxAccessCount=Max Access Count
labels.name=Name

labels.excludedUrls=Excluded URLs For Crawling
labels.excludedDocPaths=Excluded Paths For Indexing
labels.excludedDocUrls=Excluded URLs For Indexing
labels.hostname=Hostname
labels.id=ID
labels.includedPaths=Included Paths For Crawling
labels.includedUrls=Included URLs For Crawling
labels.includedDocPaths=Included Paths For Indexing
labels.includedDocUrls=Included URLs For Indexing
labels.maxAccessCount=Max Access Count
labels.name=Name

package p

// Assignability of an unnamed pointer type to a type parameter that
// has a matching underlying type.
func _[T interface{}, PT interface{ ~*T }](x T) PT {
	return &x
}

// Indexing of generic types containing type parameters in their type list:
func at[T interface{ ~[]E }, E any](x T, i int) E {
	return x[i]
}

// A generic type inside a function acts like a named type. Its underlying