* 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);

 * 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 projectToInspector.computeIfAbsent(task.getProject(), ProjectScopedTypeOriginInspector::new);
        }

        void resetState() {
            projectToInspector.clear();
        }

        @Nullable
        private File jarFileFor(Class<?> pluginClass) {

    @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