return (link == null || link.getUrl() == null) ? null : new DefaultDocumentationLink(link.getUrl());
    }

    private static List<InternalSolution> toInternalSolutions(List<String> solutions) {
        return solutions.stream()
            .map(DefaultSolution::new)
            .collect(toImmutableList());
    }


    @SuppressWarnings("unchecked")

/**
 * An extension point to provide additional symbols for a KDoc reference. KDoc link resolution will use symbols returned by this EP
 * only if the real resolution was unsuccessful. You can use this EP by creating a class implementing this interface.
 * For example, let's assume that you want to return symbol `fun foo() = 3` for the following KDoc resolution:
 *
 * ```
 *   package com.example
 *   fun foo() = 3
 *   /**

import org.jetbrains.kotlin.analysis.api.resolution.KaExplicitReceiverValue
import org.jetbrains.kotlin.analysis.api.resolution.KaFunctionCall
import org.jetbrains.kotlin.analysis.api.resolution.KaImplicitReceiverValue
import org.jetbrains.kotlin.analysis.api.resolution.KaPartiallyAppliedFunctionSymbol
import org.jetbrains.kotlin.analysis.api.resolution.KaPartiallyAppliedSymbol

 */

package org.jetbrains.kotlin.analysis.api

import org.jetbrains.kotlin.analysis.api.resolution.KaSymbolBasedReference

@OptIn(KaAnalysisApiInternals::class)
@Deprecated(
    "The API has been moved into `org.jetbrains.kotlin.analysis.api.resolution` package",
    level = DeprecationLevel.HIDDEN,
)
public typealias KaSymbolBasedReference = KaSymbolBasedReference

        val assignmentTrace = assignmentTrace(resolution)
        val assignmentErrors = assignmentTrace.elements.filterIsInstance<AssignmentTraceElement.FailedToRecordAssignment>()
        if (assignmentErrors.isNotEmpty()) {
            failureReasons += AssignmentErrors(assignmentErrors)
        }

        val analysisResult = AnalysisStepResult(evaluationSchema, languageModel, resolution, resolver.trace, assignmentTrace)

func makeService(hostname host.Name, configNamespace, address string, ports map[string]int,
	external bool, resolution model.Resolution, serviceAccounts ...string,
) *model.Service {
	svc := &model.Service{
		CreationTime:    GlobalTime,
		Hostname:        hostname,
		DefaultAddress:  address,
		MeshExternal:    external,
		Resolution:      resolution,
		ServiceAccounts: serviceAccounts,
		Attributes: model.ServiceAttributes{

* There is no validation that an ignored dependency is present in any configuration resolution.
* If the dependency is present in lock state, loading it will filter out the dependency.
* If the dependency is present in the resolution result, it will be ignored when validating that resolution matches the lock state.
* Finally, if the dependency is present in the resolution result and the lock state is persisted, it will be absent from the written lock state.

	addrs := []string{constants.UnspecifiedIP}
	resolution := model.ClientSideLB
	externalName := ""
	nodeLocal := false

	if svc.Spec.Type == corev1.ServiceTypeExternalName && svc.Spec.ExternalName != "" {
		externalName = svc.Spec.ExternalName
		if features.EnableExternalNameAlias {
			resolution = model.Alias
		} else {
			resolution = model.DNSLB
		}
	}

import org.eclipse.aether.collection.DependencyCollectionException;
import org.eclipse.aether.graph.DependencyFilter;
import org.eclipse.aether.graph.DependencyNode;
import org.eclipse.aether.resolution.ArtifactResult;
import org.eclipse.aether.resolution.DependencyRequest;
import org.eclipse.aether.util.artifact.ArtifactIdUtils;
import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;

              <exclude>org.apache.maven.model.resolution.InvalidRepositoryException#getRepository():METHOD_RETURN_TYPE_CHANGED</exclude>
              <exclude>org.apache.maven.model.resolution.InvalidRepositoryException#InvalidRepositoryException(java.lang.String,org.apache.maven.model.Repository,java.lang.Throwable):CONSTRUCTOR_REMOVED</exclude>