@Override
    public ModuleIdentifier module(String group, String name) {
        Map<String, ModuleIdentifier> byName = groupIdToModules.get(group);
        if (byName == null) {
            byName = groupIdToModules.computeIfAbsent(group, k -> new ConcurrentHashMap<>());
        }
        ModuleIdentifier moduleIdentifier = byName.get(name);
        if (moduleIdentifier == null) {

        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
                    }
                }

    override fun getTransitiveDependents(module: KtModule): Set<KtModule> =
        transitiveDependentsByKtModule.computeIfAbsent(module) { computeTransitiveDependents(it) }

    override fun getRefinementDependents(module: KtModule): Set<KtModule> = refinementDependentsByKtModule[module].orEmpty()
}

private inline fun buildDependentsMap(

                    Type constructedType = request.getInterceptedCallable().getOwner().getType();
                    String typeKey = implementationName + ":" + constructedType;
                    constructorRequests.computeIfAbsent(typeKey, k -> ConstructorInterceptorSpec.of(implementationName, constructedType, interceptorType)).getRequests().add(request);
                } else {
                    String name = NameUtil.interceptedJvmMethodName(callable);

            return (Provider<T>) passwordProviders.computeIfAbsent(identity, id -> evaluateAtConfigurationTime(new PasswordCredentialsProvider(id)));
        }
        if (AwsCredentials.class.isAssignableFrom(credentialsType)) {
            return (Provider<T>) awsProviders.computeIfAbsent(identity, id -> evaluateAtConfigurationTime(new AwsCredentialsProvider(id)));
        }

    fun <T : Any?> executeQuery(apiSourceFile: ApiSourceFile.Java, query: JavaSourceQuery<T>): T =
        openJavaCompilationUnitsByFile
            .computeIfAbsent(apiSourceFile.currentFile) { JavaParser().parse(it).getResult().get() }
            .accept(query.visitor, null)
            ?: query.defaultValue

            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)

            registerMapping(key, pkgInfo);
        }
    }

    private Optional<String> findRelativePath(File asSourceFile) {
        return relativePaths.computeIfAbsent(asSourceFile, relativize);
    }

    private String normalizeName(TypeElement typeElement) {
        String symbol = typeElement.getQualifiedName().toString();
        if (symbol.endsWith("module-info")) {

    }

    public static CallSiteDecorator getGroovyCallDecorator(BytecodeInterceptorFilter interceptorFilter) {
        return groovyDecorators.computeIfAbsent(interceptorFilter, key -> new DefaultCallSiteDecorator(currentGroovyCallInterceptorSet.getCallInterceptors(interceptorFilter)));
    }