Thing thing = new Thing("thing")
        WeakIdentityHashMap<Thing, String> map = new WeakIdentityHashMap<>()

        assert map.get(thing) == null

        String foo = map.computeIfAbsent(
            thing,
            new WeakIdentityHashMap.AbsentValueProvider<String>() {
                @Override
                String provide() {
                    return "Foo"
                }

            for (ResolvedVariant variant : sources) {
                variantAttributes.add(variant.getAttributes().asImmutable());
            }
            List<CachedVariant> cached = cache.computeIfAbsent(new CacheKey(variantAttributes, requested), key -> action.apply(key.variantAttributes, key.requested));
            List<TransformedVariant> output = new ArrayList<>(cached.size());

        return factory.anyOf(result);
    }

    public ExcludeSpec nothing() {
        return nothing;
    }

    private ExcludeSpec forExclude(ExcludeMetadata r) {
        return metadataToExcludeCache.computeIfAbsent(r, rule -> {
            // For custom ivy pattern matchers, don't inspect the rule any more deeply: this prevents us from doing smart merging later
            if (!PatternMatchers.isExactMatcher(rule.getMatcher())) {

        return strategies.containsKey(key);
    }

    @Override
    public AttributeMatcher withProducer(AttributesSchemaInternal producerSchema) {
        return matcherCache.computeIfAbsent(producerSchema, key ->
            new DefaultAttributeMatcher(new DefaultAttributeSelectionSchema(this, producerSchema)));
    }

    @Override
    public AttributeMatcher matcher() {

            return createAnalysisSession(useSiteKtModule)
        }

        val identifier = tokenFactory.identifier
        identifier.flushPendingChanges(project)

        return cache.computeIfAbsent(useSiteKtModule, ::createAnalysisSession)
    }

    private fun createAnalysisSession(useSiteKtModule: KtModule): KaFirSession {
        val firResolveSession = useSiteKtModule.getFirResolveSession(project)

            return new ArtifactsForNode(id, new VariantResolvingArtifactSet(variantResolver, component, variant, dependency, graphVariantSelector, consumerSchema));
        }

        return artifactsByNodeId.computeIfAbsent(toNode.getNodeId(), (LongFunction<ArtifactsForNode>) value -> {
            int id = nextId++;

        if (softwareTypeImplementations != null) {
            throw new IllegalStateException("Cannot register a plugin after software types have been discovered");
        }
        pluginClasses.computeIfAbsent(registeringPluginClass, k -> new LinkedHashSet<>()).add(pluginClass);
    }

    private Set<SoftwareTypeImplementation<?>> discoverSoftwareTypeImplementations() {

            { loader.getResourceAsStream(classFilePath).use { it!!.readBytes() } }
        }
    }

    private
    fun openJarFile(file: File) =
        openJars.computeIfAbsent(file, ::JarFile)

    override fun close() {
        openJars.values.forEach(JarFile::close)
    }
}


/**

                Attribute<?> attribute = candidateAttribute.getAttribute();
                Set<String> unrequestedValuesForAttribute = unrequestedAttributesWithValues.computeIfAbsent(attribute.getName(), name -> new HashSet<>());
                unrequestedValuesForAttribute.add(Objects.requireNonNull(candidateAttribute.getProvided()).toString());
            });
        });

            throw uoe();
        }

        @Override
        public Object replace(Object key, Object value) {
            throw uoe();
        }

        @Override
        public Object computeIfAbsent(Object key, Function<? super Object, ?> mappingFunction) {
            throw uoe();
        }

        @Override