.collect(Collectors.toList());
        });
        return variant;
    }

    /**
     * A custom artifact type which allows the getFile call to be done lazily only when the
     * artifact is actually needed.
     */
    private static class LazyJavaDirectoryArtifact extends AbstractPublishArtifact {
        private final String type;

  private val messageBuffer = Buffer()

  /** The [Buffer] of [sink]. Write to this and then flush/emit [sink]. */
  private val sinkBuffer: Buffer = sink.buffer
  private var writerClosed = false

  /** Lazily initialized on first use. */
  private var messageDeflater: MessageDeflater? = null

  // Masks are only a concern for client writers.
  private val maskKey: ByteArray? = if (isClient) ByteArray(4) else null

type emptyMapList struct{}

func (emptyMapList) Get(interface{}) interface{} {
	return nil
}

type mapListImpl struct {
	sts Schema
	ks  keyStrategy
	// keyedItems contains all lazily keyed map items
	keyedItems map[interface{}]interface{}
	// unkeyedItems contains all map items that have not yet been keyed
	unkeyedItems []interface{}
}

func (a *mapListImpl) Get(obj interface{}) interface{} {

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name

/**
 * Implements [KaNamedClassOrObjectSymbol] for a Java class. The underlying [firSymbol] is built lazily and only when needed. Many simple
 * properties are computed from the given [PsiClass] instead of [firSymbol]. This improves performance when "slow" properties don't need to
 * be accessed.
 */

		// condition that persists as long as the local side keeps the
		// socket open. The condition is rare as it is typical in most
		// protocols for both sides to issue a close; this typically
		// occurs when the local socket is lazily garbage collected.
		//
		// If the CLOSE_WAIT conntrack entry expires, then FINs from the
		// local socket will not be properly SNAT'd and will not reach the

import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Common base class for the lazy versions of {@link ModuleComponentResolveMetadata} implementations.
 *
 * The lazy part is about the application of {@link VariantMetadataRules} which are applied lazily
 * when configuration or variant data is required by consumers.
 *

                }
                project(":a", "test:a:")
            }
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/25579")
    def "can lazily compute dependencies from results of another resolution which resolves current project"() {
        buildFile << """
            configurations {
                a
                b
                create("default")

  limit: Int,
  encodeSet: String,
  alreadyEncoded: Boolean,
  strict: Boolean,
  plusIsSpace: Boolean,
  unicodeAllowed: Boolean,
  charset: Charset?,
) {
  var encodedCharBuffer: Buffer? = null // Lazily allocated.
  var codePoint: Int
  var i = pos
  while (i < limit) {
    codePoint = input.codePointAt(i)
    if (alreadyEncoded && (
        codePoint == '\t'.code || codePoint == '\n'.code ||

	// should only be populated for schema nodes where this is true.
	withinValidationRuleScope bool

	// typeInfo is lazily loaded for schema nodes withinValidationRuleScope and may be
	// populated one of two possible ways:
	//   1. Using a typeInfoAccessor to access it from the parent's type info. This is a cheap operation and should be

  exit 1
}

if [ -z "${MOUNTER_IMAGE}" ]; then
  echo "ERROR: No Container Registry mounter image is specified."
  echo
  usage
fi

# Unmounts a mount point lazily. If a mount point does not exist, continue silently,
# and without error.
umount_silent() {
  umount -l "$1" &> /dev/null || /bin/true
}

# Waits for kubelet to restart for 1 minute.
kubelet_wait() {
  timeout=60