return version != null ? versionSelectors.computeIfAbsent(version, s -> versionSelectorScheme.parseSelector(version)) : null;
        }
    }

    private static class PatternSpecMatcher implements SpecMatcher {
        private final Pattern groupPattern;

            String relativePath = compilationSourceDirs.relativize(new File(sourceUnit.getSource().getURI().getPath())).orElseThrow(IllegalStateException::new);
            result.getSourceClassesMapping().computeIfAbsent(relativePath, key -> new HashSet<>()).add(classFqName);
            compilationClassBackupService.maybeBackupClassFile(classFqName);
            Iterator<InnerClassNode> iterator = classNode.getInnerClasses();

    }

    private static final Map<CI, String> CI_INJECTION_SCRIPT_CONTENTS = new ConcurrentHashMap<>()

    private static String getCiInjectionScriptContent(CI ci) {
        return CI_INJECTION_SCRIPT_CONTENTS.computeIfAbsent(ci) { new URL(it.getUrl()).getText(StandardCharsets.UTF_8.name()) }
    }

    private static final List<String> UNSUPPORTED = [
        "2.4.2",
        "2.4.1",
        "2.4",
        "2.3",
        "2.2.1",

        accessibilityInfoFor(className).hasTypeParameter

    private
    fun accessibilityInfoFor(className: String): TypeAccessibilityInfo =
        typeAccessibilityInfoPerClass.computeIfAbsent(className) {
            loadAccessibilityInfoFor(it)
        }

    private
    fun loadAccessibilityInfoFor(className: String): TypeAccessibilityInfo {

        return dependencyStateCache.computeIfAbsent(md, this::createDependencyState);
    }

    private void createAndLinkEdgeState(DependencyState dependencyState, Collection<EdgeState> discoveredEdges, ExcludeSpec resolutionFilter, boolean deferSelection) {
        EdgeState dependencyEdge = edgesCache.computeIfAbsent(dependencyState, ds -> new EdgeState(this, ds, resolutionFilter, resolveState));

                    queue.addLast(mappingForSupertype)
                }

                for ((typeParameterDescriptor, boundTypeArgument) in mapping) {
                    val boundsForParameter = typeArgumentMapping.computeIfAbsent(typeParameterDescriptor) {
                        var isCompatible = true
                        val languageVersionSettings = analysisContext.resolveSession.languageVersionSettings

        DirectoryContents(File searchDir) {
            this.searchDir = searchDir;
        }

        CachedIncludeFile get(String includePath) {
            return contents.computeIfAbsent(includePath,
                key -> {
                    File candidate = normalizeIncludePath(searchDir, includePath);
                    return fileSystemAccess.readRegularFileContentHash(candidate.getAbsolutePath())

     * Includes type bindings from a whole class hierarchy
     */
    public static Map<TypeVariable<?>, Type> getAllTypeBindings(Type type) {
        return TYPE_BINDINGS_CACHE.computeIfAbsent(type, t -> {
            Map<TypeVariable<?>, Type> mapping = new HashMap<>();
            getAllTypeBindingsImpl(t, mapping);
            return mapping;
        });
    }

        Class<? extends ExternalModuleDependencyFactory> factory;
        synchronized (this) {
            factory = factories.computeIfAbsent(accessorsClassnameSuffix, n ->
                loadFactory(classLoaderScope, ACCESSORS_PACKAGE + "." + ACCESSORS_CLASSNAME_PREFIX + accessorsClassnameSuffix)
            );
        }
        return factory;
    }

        final Set<MavenProject> projectsIncludingParents = new HashSet<>();
        for (MavenProject project : session.getProjects()) {
            superPomModels.computeIfAbsent(
                    project.getModelVersion(),
                    v -> superPomProvider.getSuperModel(v).getDelegate());
            boolean isAdded = projectsIncludingParents.add(project);