public <T> T computeIfAbsent(String groupId, String artifactId, String version, String tag, Supplier<T> data) {
        return (T) computeIfAbsent(new GavCacheKey(groupId, artifactId, version, tag), data);
    }

    @Override
    @SuppressWarnings({"unchecked"})
    public <T> T computeIfAbsent(Source path, String tag, Supplier<T> data) {
        return (T) computeIfAbsent(new SourceCacheKey(path, tag), data);
    }

            if (pluginDeclaration != null) {
                pluginDeclarations.add(pluginDeclaration);
            }
            mojoIssues
                    .computeIfAbsent(issueLocality, k -> new LinkedHashMap<>())
                    .computeIfAbsent(mojoInfo, k -> new LinkedHashSet<>())
                    .add(issue);
        }
    }

import java.util.function.Function;

/**
 * A cache backed by calculated values. This map is thread-safe.
 */
public interface CalculatedValueCache<K, V> {

    /**
     * @see Map#computeIfAbsent(Object, Function)
     */
    V computeIfAbsent(K key, Function<K, V> factory);

    /**
     * @see Map#clear()
     */
    void clear();

    private fun addToFacadeFileMap(file: KtFile) {
        if (!file.hasTopLevelCallables()) return
        index.facadeFileMap.computeIfAbsent(file.packageFqName) {
            mutableSetOf()
        }.add(file)
    }

    private fun addToScriptMap(script: KtScript) {
        index.scriptMap.computeIfAbsent(script.fqName) {
            mutableSetOf()
        }.add(script)
    }

 * model builder.
 *
 */
public interface ModelCache {

    <T> T computeIfAbsent(String groupId, String artifactId, String version, String tag, Supplier<T> data);

    <T> T computeIfAbsent(Source path, String tag, Supplier<T> data);

        return originalComponents.computeIfAbsent(projectIdentifier, id -> localComponentCache.computeIfAbsent(projectState, localComponentProvider::getComponent));
    }

    private LocalComponentGraphResolveState getLocalComponentWithForeignId(ProjectComponentIdentifier projectIdentifier) {
        return foreignIdentifiedComponents.computeIfAbsent(projectIdentifier, this::copyComponentWithForeignId);
    }

    /**

                        def containingJars = classesIndex.computeIfAbsent(name, k -> [])
                        containingJars.add(jar.name)
                    }

                    if (all.size() > 1) {
                        def jarPath = jar.absolutePath - testDirectory.absolutePath
                        jarsWithDuplicateFiles.computeIfAbsent(jarPath, { [] }) << name
                    }
                }

            this.type = type;
            this.calculatedValueContainerFactory = calculatedValueContainerFactory;
        }

        @Override
        public V computeIfAbsent(K key, Function<K, V> factory) {
            CalculatedValue<V> value = cache.computeIfAbsent(key, k ->
                calculatedValueContainerFactory.create(
                    Describables.of(k, type),
                    context -> factory.apply(k)

        return allRepositories.computeIfAbsent(repository, DefaultRemoteRepository::new);
    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node) {
        return getNode(node, false);
    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose) {
        return allNodes.computeIfAbsent(node, n -> new DefaultNode(this, n, verbose));

        }
    }

    private Set<String> computeAndCacheInstrumentedSuperTypes(String type, Set<String> visited) {
        // We intentionally avoid using computeIfAbsent, since ConcurrentHashMap doesn't allow map modifications in the computeIfAbsent map function.
        // The result is, that multiple threads could recalculate the same key multiple times, but that is not a problem in our case.