then:
        container.findByType(List) is extension
        container.findByType(new TypeOf<List<String>>() {}) is extension
    }

    def "can distinguish unrelated generic type arguments"() {
        given:
        def parents = []
        def capabilities = []

        when:
        container.add new TypeOf<List<Parent>>() {}, "parents", parents

  // +optional
  optional ReplicaSetStatus status = 3;
}

// ReplicaSetSpec is the specification of a ReplicaSet.
message ReplicaSetSpec {
  // Replicas is the number of desired replicas.
  // This is a pointer to distinguish between explicit zero and unspecified.
  // Defaults to 1.
  // More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller
  // +optional

	// Save the result of the first call to DefaultDir for later use in
	// initDefaultCache. cmd/go/main.go explicitly sets GOCACHE so that
	// subprocesses will inherit it, but that means initDefaultCache can't
	// otherwise distinguish between an explicit "off" and a UserCacheDir error.

	defaultDirOnce.Do(func() {
		defaultDir = cfg.Getenv("GOCACHE")
		if defaultDir != "" {
			defaultDirChanged = true

   *   putIfZero.
   *
   * - Allow putIfAbsent and replace to distinguish between zero and absent, but don't implement
   *   remove(K, long). Without any two-phase operations it becomes feasible for all remaining
   *   operations to distinguish between zero and absent. If we do this, then perhaps we should add
   *   replace(key, long).
   *

//
// Other packages in std that import internal/poll and are unable to
// import net (such as os) can use a type assertion to access this
// extension method so that they can distinguish different socket types.
//
// Network is not intended for use outside the standard library.
func (c *rawConn) Network() poll.String {
	return poll.String(c.fd.net)
}

type rawListener struct {
	rawConn
}

  Status status;
  for (se::Stream* stream : streams_defined_on_) {
    status.Update(stream->RefreshStatus());
  }
  return status;
}

// The pointer tag, OR-ed into the XlaTensor's address to distinguish it from
// device-side tensors, which are either CPU or GPU memory pointers. This works
// because we're guaranteed that CPU and GPU pointers are aligned to > 1 bits.
namespace {
constexpr uintptr_t kTag = 0x1ULL;
}

 * possibly run in another thread. That cause should itself be an {@code Error}; if not, use {@code
 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to
 * continue to distinguish between exceptions and errors, even when they come from other threads.
 *
 * @author Chris Povirk
 * @since 10.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class ExecutionError extends Error {

	// UnsafePointRestart1(2) apply on a sequence of instructions, within
	// which if an async preemption happens, we should back off the PC
	// to the start of the sequence when resuming.
	// We need two so we can distinguish the start/end of the sequence
	// in case that two sequences are next to each other.
	UnsafePointRestart1 = -3
	UnsafePointRestart2 = -4

	// Like UnsafePointRestart1, but back to function entry if async preempted.

 */
public abstract class MissingAttributeAmbiguousGraphVariantsFailureDescriber extends AmbiguousGraphVariantsFailureDescriber {
    /**
     * Map from failure -> name of attribute that would distinguish each candidate.
     * This map exists to avoid re-discovering the unrequested attributes between the calls to `canDescribeFailure` and `describeFailure`.

     * associated result file.
     */
    protected abstract val modificationEventKind: KotlinModificationEventKind

    /**
     * A suffix for the result file to distinguish it from the results of other session invalidation tests if the results are different.
     */
    protected abstract val resultFileSuffix: String?

    protected abstract fun getSession(ktModule: KtModule): SESSION