return writeOperation(p -> p.replace(key, value));
    }

    @Override
    public synchronized Object computeIfAbsent(Object key, Function<? super Object, ?> mappingFunction) {
        return writeOperation(p -> p.computeIfAbsent(key, mappingFunction));
    }

    @Override
    public synchronized Object computeIfPresent(

     */
    public ImmutableAttributes desugar(ImmutableAttributes attributes) {
        if (attributes.isEmpty()) {
            return attributes;
        }
        return desugared.computeIfAbsent(attributes,  key -> {
            AttributeContainerInternal mutable = attributesFactory.mutable();
            Set<Attribute<?>> keySet = key.keySet();
            for (Attribute<?> attribute : keySet) {

import java.util.*;

class Graph {

    final Map<String, Set<String>> graph = new LinkedHashMap<>();

    synchronized void addEdge(String from, String to) throws CycleDetectedException {
        if (graph.computeIfAbsent(from, l -> new HashSet<>()).add(to)) {
            List<String> cycle = visitCycle(graph, Collections.singleton(to), new HashMap<>(), new LinkedList<>());
            if (cycle != null) {

                packages.getOrPut(currentPackage) { mutableSetOf() } += subPackage
                currentPackage = currentPackage.child(subPackage)
            }
            packages.computeIfAbsent(currentPackage) { mutableSetOf() }
        }
        packages
    }

    override fun doesKotlinOnlyPackageExist(packageFqName: FqName): Boolean {

    public DefaultSuperPomProvider(ModelProcessor modelProcessor) {
        this.modelProcessor = modelProcessor;
    }

    @Override
    public Model getSuperPom(String version) {
        return SUPER_MODELS.computeIfAbsent(Objects.requireNonNull(version), v -> readModel(version, v));
    }

    private Model readModel(String version, String v) {
        String resource = "/org/apache/maven/model/pom-" + v + ".xml";

                allHandlers.clear();
            }
        }
    }

    @Override
    public ArtifactHandler getArtifactHandler(String id) {
        return allHandlers.computeIfAbsent(id, k -> {
            Type type = typeRegistry.require(id);
            return new DefaultArtifactHandler(
                    id,
                    type.getExtension(),
                    type.getClassifier(),

        lifecycle.phases().forEach(phase -> phase.plugins()
                .forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
                        .forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())
                                .add(plugin.getGroupId() + ":" + plugin.getArtifactId() + ":" + plugin.getVersion()
                                        + ":" + goal)))));

     */
    class DependencyCache {
        private final Map<String, DefaultLocalConfigurationMetadataBuilder.DependencyState> cache = new HashMap<>();

        public DefaultLocalConfigurationMetadataBuilder.DependencyState computeIfAbsent(
            ConfigurationInternal configuration,
            Function<ConfigurationInternal, DependencyState> factory
        ) {
            DependencyState state = cache.get(configuration.getName());

        ConfigurationInternal configurationInternal = (ConfigurationInternal) configuration;
        Set<TaskProvider<COMPILE>> compileTasks = Cast.uncheckedCast(configurationToCompileTasks.computeIfAbsent(configurationInternal, key -> new HashSet<>()));
        compileTasks.add(compileTask);

        JavaPluginExtension java = project.getExtensions().getByType(JavaPluginExtension.class);

                            // Ignore
                        }
                    }
                }
            }
            return model;
        }

        public Model computeIfAbsent(Supplier<Model> supplier) {
            if (!set) {
                synchronized (this) {
                    if (!set) {
                        this.set = true;
                        this.model = supplier.get();