}
            }
        }
    }
}

public abstract class KaReferenceShortener : KaSessionComponent() {
    public abstract fun collectShortenings(
        file: KtFile,
        selection: TextRange,
        shortenOptions: ShortenOptions,
        classShortenStrategy: (KaClassLikeSymbol) -> ShortenStrategy,
        callableShortenStrategy: (KaCallableSymbol) -> ShortenStrategy
    ): ShortenCommand
}

workspace's modules

The workspace's build list is the set of versions of all the
(transitive) dependency modules used to do builds in the workspace. go
work sync generates that build list using the Minimal Version Selection
algorithm, and then syncs those versions back to each of modules
specified in the workspace (with use directives).

The syncing is done by sequentially upgrading each of the dependency

 * limitations under the License.
 */

package org.gradle.internal.component.resolution.failure.type;

/**
 * A {@link ResolutionFailure} that represents the an unknown, catch-all failure that occurred during variant selection.
 */
public final class UnknownArtifactSelectionFailure extends AbstractVariantSelectionFailure {
    private final Exception cause;

    public UnknownArtifactSelectionFailure(String requestedName, Exception cause) {

 * limitations under the License.
 */
package okhttp3.internal

import java.net.InetAddress
import okhttp3.Dns

/**
 * A network that always resolves two IP addresses per host. Use this when testing route selection
 * fallbacks to guarantee that a fallback address is available.
 */
class DoubleInetAddressDns : Dns {
  override fun lookup(hostname: String): List<InetAddress> {
    val addresses = Dns.SYSTEM.lookup(hostname)

import org.gradle.tooling.TestLauncher

@ToolingApiVersion(">=7.6")
@TargetGradleVersion(">=8.4")
class TestLauncherTaskExecutionCrossVersionSpec extends ToolingApiSpecification {

    def "can run tasks without test selection"() {
        setup:
        buildFile << """
            tasks.register('foo') {
                doLast {
                    System.out.println 'foo'
                }
            }
        """

	LeaseMeta  metav1.ObjectMeta
	Client     coordinationv1client.LeasesGetter
	LockConfig ResourceLockConfig
	lease      *coordinationv1.Lease
}

// Get returns the election record from a Lease spec
func (ll *LeaseLock) Get(ctx context.Context) (*LeaderElectionRecord, []byte, error) {
	var err error

  $ kubectl delete clusterrolebinding spire-server-cluster-role-binding spire-agent-cluster-role-binding manager-role-binding
  $ kubectl delete role spire-server-role leader-election-role
  $ kubectl delete rolebinding spire-server-role-binding leader-election-role-binding
  $ kubectl delete ValidatingWebhookConfiguration spire-controller-manager-webhook
  $ kubectl delete csidriver csi.spiffe.io

 * limitations under the License.
 */

package org.gradle.internal.component.model;

import java.util.List;

/**
 * This class is used to return the results of variant selection when building a dependency graph
 * using the {@link GraphVariantSelector}.
 */
public class GraphVariantSelectionResult {
    private final List<? extends VariantGraphResolveState> variants;

    metadata:
      name: config
    etcd:
      local:
        # Run etcd in a tmpfs (in RAM) for performance improvements
        dataDir: /tmp/kind-cluster-etcd
    # We run single node, drop leader election to reduce overhead
    controllerManager:
      extraArgs:
        leader-elect: "false"
    scheduler:
      extraArgs:
        leader-elect: "false"
    apiServer:
      extraArgs:

    ComponentSelector project(String path);

    /**
     * Transforms the supplied selector into a specific variant selector.
     *
     * @param selector the origin selector
     * @param detailsAction the variant selection details configuration
     * @since 6.6
     */
    ComponentSelector variant(ComponentSelector selector, Action<? super VariantSelectionDetails> detailsAction);

    /**