testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtDeclaration>(testServices).single().first

        val restoreAt =
            testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtElement>(
                testServices,
                caretTag = "restoreAt"
            ).single().first

        val project = declaration.project

  <T2 extends T> Ordering<Entry<T2, ?>> onKeys() {
    return onResultOf(Maps.<T2>keyFunction());
  }

  /**
   * Returns an ordering which first uses the ordering {@code this}, but which in the event of a
   * "tie", then delegates to {@code secondaryComparator}. For example, to sort a bug list first by
   * status and second by priority, you might use {@code byStatus.compound(byPriority)}. For a

        get() = withValidityAssertion {
            fe10Type.formatParams.first().split('.').map {
                KaClassTypeQualifier.KaUnresolvedClassTypeQualifier(Name.guessByFirstCharacter(it), emptyList(), token)
            }
        }

    @KaAnalysisNonPublicApi
    override val presentableText: String?
        get() = withValidityAssertion { fe10Type.formatParams.first() }

    @KaAnalysisNonPublicApi

	// overlap.
	var pv pairVisitor
	first := pv.init(is, is2)
	for {
		second := pv.nxt()
		if second.done() {
			break
		}
		if first.pairIndex == second.pairIndex {
			first = second
			continue
		}
		if first.i.Overlaps(second.i) {
			return true
		}
		first = second
	}
	return false
}

                return new AbstractMap.SimpleEntry<>(key, replacedAccessor);
            });
    }

    private static <T> Map<AccessorKey, T> diff(Map<AccessorKey, T> first, Map<AccessorKey, T> second) {
        return first.entrySet().stream()
            .filter(e -> !second.containsKey(e.getKey()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

			r.Comma = tt.Comma
			r.Comment = tt.Comment
			r.LazyQuotes = tt.LazyQuotes
			r.TrimLeadingSpace = tt.TrimLeadingSpace

			records, err := r.ReadAll()
			if err != nil {
				continue
			}
			t.Logf("first records = %#v", records)

			buf.Reset()
			w := NewWriter(buf)
			w.Comma = tt.Comma
			err = w.WriteAll(records)
			if err != nil {
				t.Logf("writer  = %#v\n", w)
				t.Logf("records = %v\n", records)

      if (valueReference.isLoading()) {
        valueReference.notifyNewValue(null);
        return first;
      } else {
        return removeEntryFromChain(first, entry);
      }
    }

    @GuardedBy("this")
    @CheckForNull
    ReferenceEntry<K, V> removeEntryFromChain(
        ReferenceEntry<K, V> first, ReferenceEntry<K, V> entry) {
      int newCount = count;

// Package stdlib provides a table of all exported symbols in the
// standard library, along with the version at which they first
// appeared.
package stdlib

import (
	"fmt"
	"strings"
)

type Symbol struct {
	Name    string
	Kind    Kind
	Version Version // Go version that first included the symbol
}

// A Kind indicates the kind of a symbol:
// function, variable, constant, type, and so on.

        !result.watchingEnabled
        result.statistics == null
    }

    private Map<String, ?> buildStartedResult() {
        operations.first(BuildStartedFileSystemWatchingBuildOperationType).result
    }

    private Map<String, ?> buildFinishedResult() {
        operations.first(BuildFinishedFileSystemWatchingBuildOperationType).result
    }

    private static boolean retainedFiles(Map<String, ?> result) {

	}
}

type BadPathTestA struct {
	First  string `xml:"items>item1"`
	Other  string `xml:"items>item2"`
	Second string `xml:"items"`
}

type BadPathTestB struct {
	Other  string `xml:"items>item2>value"`
	First  string `xml:"items>item1"`
	Second string `xml:"items>item1>value"`
}

type BadPathTestC struct {
	First  string
	Second string `xml:"First"`
}

type BadPathTestD struct {