override fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T = tags.computeIfAbsent(type, computeIfAbsent)

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,
  ): T = tags.computeIfAbsent(type.kotlin, computeIfAbsent)

  @SuppressWarnings("CloneDoesntCallSuperClone") // We are a final type & this saves clearing state.

        }
        return plural;
    }

    private void recordString(String path, String value) {
        pathStats
                .computeIfAbsent(path, k -> new HashMap<>())
                .computeIfAbsent(value, k -> new StringStats())
                .recordOccurrence(value);
    }

    List<PathAnalysis> getPathAnalysisSorted() {

            if (allProjects != null) {
                Map<String, Map<String, Map<String, MavenProject>>> map = new HashMap<>();
                allProjects.forEach(project -> map.computeIfAbsent(project.getGroupId(), k -> new HashMap<>())
                        .computeIfAbsent(project.getArtifactId(), k -> new HashMap<>())
                        .put(project.getVersion(), project));
                this.allProjects = map;
            } else {

            SessionData data = session.getSession().getData();
            Map<MavenProject, OwnerReentrantLock> locks = data.computeIfAbsent(PROJECT_LOCKS, ConcurrentHashMap::new);
            return locks.computeIfAbsent(session.getCurrentProject(), p -> new OwnerReentrantLock());
        }
    }

    static class OwnerReentrantLock extends ReentrantLock {
        @Override

            return false;
        }

        // Check per-account limit
        if (username != null) {
            AccountAttempts account = accountAttempts.computeIfAbsent(username, k -> new AccountAttempts());
            if (account.isLockedOut()) {
                if (account.getLockoutExpiry().isAfter(Instant.now())) {
                    totalAttemptsBlocked.incrementAndGet();

        if (setterInfo == null) {
            // Look for any method named "set" with one parameter
            Map<String, MethodInfo> classMethodCache = METHOD_CACHE.computeIfAbsent(beanType, this::buildMethodCache);
            setterInfo = classMethodCache.get("set");
        }

        if (setterInfo == null) {

        if (outputEvent.getMessage().startsWith(REPRODUCE_WITH_PREFIX)) {
            Deque<String> lines = reproductionLines.computeIfAbsent(Descriptor.of(suite), d -> new LinkedList<>());
            lines.add(outputEvent.getMessage());
        }

        EventWriter eventWriter = eventWriters.computeIfAbsent(Descriptor.of(suite), EventWriter::new);
        eventWriter.write(outputEvent);
    }

    @Override

        vFrom.setCompareScope(scopedVertices);

        List<MetadataGraphEdge> exList = excidentEdges.computeIfAbsent(vFrom, k -> new ArrayList<>());

        if (!exList.contains(e)) {
            exList.add(e);
        }

        List<MetadataGraphEdge> inList = incidentEdges.computeIfAbsent(vTo, k -> new ArrayList<>());

        if (!inList.contains(e)) {
            inList.add(e);
        }

        }

        private LongAdder getCounter(BuilderProblem.Severity severity) {
            return counters.computeIfAbsent(severity, k -> new LongAdder());
        }

        private List<P> getProblems(BuilderProblem.Severity severity) {
            return problems.computeIfAbsent(severity, k -> new CopyOnWriteArrayList<>());
        }

            }, depsTask);

            if (distribution.getPlatform() == Platform.WINDOWS) {
                windowsTestTasks.add(destructiveTask);
            } else {
                linuxTestTasks.computeIfAbsent(distribution.getType(), k -> new ArrayList<>()).add(destructiveTask);
            }
            destructiveDistroTest.configure(t -> t.dependsOn(destructiveTask));