@OptIn(KaAnalysisNonPublicApi::class) // used in IDEA K1 evaluator
@Suppress("unused")
fun KaSession.getInlineFunctionAnalyzer(analyzeOnlyReifiedInlineFunctions: Boolean): InlineFunctionAnalyzer {
    require(this is KaFe10Session) {
        "K2 implementation shouldn't call this code"
    }
    return InlineFunctionAnalyzer(analysisContext, analyzeOnlyReifiedInlineFunctions)
}

@OptIn(KaAnalysisNonPublicApi::class)
class InlineFunctionAnalyzer(

		},
		{
			inputXML: `<Rule>
				<ID>Rule with multiple tags and DelMarkerExpiration</ID>
				<Filter><And>
				<Tag><Key>k1</Key><Value>v1</Value></Tag>
				<Tag><Key>k2</Key><Value>v2</Value></Tag>
				</And></Filter>
				<DelMarkerExpiration>
					<Days>365</Days>
				</DelMarkerExpiration>
                            <Status>Enabled</Status>
	                    </Rule>`,

        val effectiveSession = if (positionModule is KtDanglingFileModule && candidateModule != positionModule) {
            @Suppress("USELESS_CAST") // Smart cast is only available in K2
            val contextModule = (positionModule as KtDanglingFileModule).contextModule
            firResolveSession.getSessionFor(contextModule)
        } else {
            firResolveSession.getSessionFor(positionModule)

    )

    val DO_NOT_CHECK_SYMBOL_RESTORE_K2 by directive(
        description = "Symbol restoring for some symbols in current test is not supported yet in K2",
    )

    val DO_NOT_CHECK_NON_PSI_SYMBOL_RESTORE by directive(
        description = "Symbol restoring w/o psi for some symbols in current test is not supported yet",
    )

            .addValue(Arrays.asList("C"))
            .addValue(Arrays.asList())
            .add(SHORT_NAME, Collections.singletonMap("k1", "v1"))
            .add(LONG_NAME, Collections.singletonMap("k2", "v2"))
            .addValue(Collections.singletonMap("k3", "v3"))
            .addValue(Collections.emptyMap())
            .addValue(null)
            .add(SHORT_NAME, Optional.of("1"))

				"optional.ofNonZeroValue(duration('0s')) == optional.none()",

				"{?'k': optional.none(), 'k2': 'v2'} == {'k2': 'v2'}",
				"{?'k': optional.of('v'), 'k2': 'v2'} == {'k': 'v', 'k2': 'v2'}",
				"['a', ?optional.none(), 'c'] == ['a', 'c']",
				"['a', ?optional.of('v'), 'c'] == ['a', 'v', 'c']",
			},
			errors: map[string]string{

				if b.tophash[i] == emptyRest {
					break search
				}
				continue
			}
			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.KeySize))
			k2 := k
			if t.IndirectKey() {
				k2 = *((*unsafe.Pointer)(k2))
			}
			if !t.Key.Equal(key, k2) {
				continue
			}
			// Only clear key if there are pointers in it.
			if t.IndirectKey() {
				*(*unsafe.Pointer)(k) = nil
			} else if t.Key.Pointers() {

}

//////////////// Other

// Equal reports whether v and w represent the same Go value.
func (v Value) Equal(w Value) bool {
	k1 := v.Kind()
	k2 := w.Kind()
	if k1 != k2 {
		return false
	}
	switch k1 {
	case KindInt64, KindUint64, KindBool, KindDuration:
		return v.num == w.num
	case KindString:
		return v.str() == w.str()
	case KindFloat64:

                .filter(e -> e.getValue() != null)
                .collect(Collectors.toMap(
                        e -> String.valueOf(e.getKey()), e -> String.valueOf(e.getValue()), (k1, k2) -> k2));
    }

    private String getUserAgent() {
        String version = runtimeInformation.getMavenVersion();
        version = version.isEmpty() ? version : "/" + version;

   * to the set.
   *
   * <p><b>Warning:</b> This method assumes that for any instance {@code k} of key type {@code K},
   * {@code k.equals(k2)} implies that {@code k2} is also of type {@code K}. Using a key type for
   * which this may not hold, such as {@code ArrayList}, may risk a {@code ClassCastException} when
   * calling methods on the resulting map view.
   *