}

    @Override
    @SuppressWarnings({"unchecked"})
    public <T> T computeIfAbsent(String groupId, String artifactId, String version, String tag, Supplier<T> data) {
        return (T) computeIfAbsent(new GavCacheKey(groupId, artifactId, version, tag), data);
    }

    @Override
    @SuppressWarnings({"unchecked"})
    public <T> T computeIfAbsent(Source path, String tag, Supplier<T> data) {

                    }
                    List<Supplier<Object>> list =
                            res3.stream().map(this::compile).collect(Collectors.toList());
                    //noinspection unchecked
                    return () -> (Q) list(list);
                }
                if (key.getRawType() == Map.class) {
                    Key<?> k = key.getTypeParameter(0);

import org.apache.maven.api.Type;
import org.apache.maven.api.di.Named;
import org.apache.maven.api.spi.TypeProvider;

@Named
public class DefaultTypeProvider implements TypeProvider {
    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public Collection<Type> provides() {
        return (Collection) types();
    }

    public Collection<DefaultType> types() {
        return Arrays.asList(
                // Maven types

    @Test
    public void testPluginArtifactsExpressionReference() throws Exception {
        Session session = newSession();
        MojoExecution exec = newMojoExecution(session);

        @SuppressWarnings("unchecked")
        Collection<Artifact> depResults = (Collection<Artifact>)
                new PluginParameterExpressionEvaluatorV4(session, null, exec).evaluate("${mojo.plugin.dependencies}");

        public <T> void seed(Class<T> clazz, Provider<T> value) {
            provided.put(Key.get(clazz), new CachingProvider<>(value));
        }

        @SuppressWarnings("unchecked")
        public <T> Provider<T> scope(Key<T> key, Provider<T> unscoped) {
            Provider<?> provider = provided.computeIfAbsent(key, k -> new CachingProvider<>(unscoped));
            return (Provider<T>) provider;

    /* MNG-4129 */
    @Test
    void testPluginExecutionInheritanceWhenChildDoesNotDeclarePlugin() throws Exception {
        PomTestWrapper pom = buildPom("plugin-exec-inheritance/wo-merge");
        @SuppressWarnings("unchecked")
        List<PluginExecution> executions = (List<PluginExecution>) pom.getValue(
                "build/pluginsAsMap[@name='org.apache.maven.its.plugins:maven-it-plugin-log-file']/executions");

    private static final Logger LOGGER = LoggerFactory.getLogger(MojoExecutor.class);
    private static final SessionData.Key<ProjectIndex> PROJECT_INDEX = SessionData.key(ProjectIndex.class);

    @SuppressWarnings({"unchecked", "rawtypes"})
    private static final SessionData.Key<Map<MavenProject, OwnerReentrantLock>> PROJECT_LOCKS =
            (SessionData.Key) SessionData.key(Map.class, ProjectLock.class);

            }

            legacySupport.setSession(session);

            // NOTE: DuplicateArtifactAttachmentException is currently unchecked, so be careful removing this try/catch!
            // This is necessary to avoid creating compatibility problems for existing plugins that use
            // MavenProjectHelper.attachArtifact(..).
            try {

    }

    public ExtensionRealmCache.CacheRecord setupExtensionsRealm(
            MavenProject project, Plugin plugin, RepositorySystemSession session) throws PluginManagerException {
        @SuppressWarnings("unchecked")
        Map<String, ExtensionRealmCache.CacheRecord> pluginRealms =
                (Map<String, ExtensionRealmCache.CacheRecord>) project.getContextValue(KEY_EXTENSIONS_REALMS);
        if (pluginRealms == null) {

            spec = new ArtifactSpec();
            spec.artifact = artifact;
            source.addArtifact(spec);
        }
        return spec;
    }

    @SuppressWarnings("unchecked")
    private static Set<Artifact> createSet(Object[] x) {
        return new LinkedHashSet(Arrays.asList(x));
    }

    private class ArtifactSpec {
        private Artifact artifact;