} catch (Exception e) {
                        throw WorkerProcessException.runFailed(getBaseName(), e);
                    }
                }
                return Cast.uncheckedNonnullCast(receiver.getNextResult());
            }
        };
    }

            task.setGroup(PUBLISH_TASK_GROUP);
        });
        extension.getPublications().all(publication -> {
            PublicationInternal<?> internalPublication = Cast.uncheckedNonnullCast(publication);
            ProjectInternal projectInternal = (ProjectInternal) project;
            projectPublicationRegistry.registerPublication(projectInternal, internalPublication);
        });

            }

            try {
                return ImmutableList.copyOf((List<FilterableCallInterceptor>) Cast.uncheckedNonnullCast(getCallInterceptors.invoke(null)));
            } catch (IllegalAccessException e) {
                throw new IllegalArgumentException("Cannot access the getCallInterceptors method in the provider class", e);

                    new DefaultSoftwareTypeImplementation<>(
                        softwareType.name(),
                        publicTypeOf(propertyMetadata, softwareType),
                        Cast.uncheckedNonnullCast(pluginClass),
                        registeringPluginClass
                    )
                );
            });
        }

            ExtensionContainer extensions = ((ExtensionAware) target).getExtensions();
            Class<?> returnType = softwareType.modelPublicType();
            extensions.add(returnType, softwareType.name(), Cast.uncheckedNonnullCast(value.call()));
        }
    }

                    }
                } catch (Exception e) {
                    throw WorkerProcessException.runFailed(getBaseName(), e);
                }
                return Cast.uncheckedNonnullCast(receiver.getNextResult());
            }
        };
    }

    }

    @Override
    public T run() throws GradleConnectionException {
        BlockingResultHandler<Object> handler = new BlockingResultHandler<Object>(Object.class);
        run(handler);
        return Cast.uncheckedNonnullCast(handler.getResult());
    }

    @Override
    public void run(ResultHandler<? super T> handler) throws IllegalStateException {

        // Enforce a copy of the dependency to avoid modifying the original dependency
        // The unchecked cast can be incorrect if D is an implementation type, but it shouldn't be used in that way.
        D copy = Cast.uncheckedNonnullCast(dependency.copy());
        modifyImplementation(copy);
        return copy;
    }

    /**
     * Modify the given dependency.
     *
     * @param dependency the dependency to modify

            Class<?> workerImplementation = Class.forName(workerImplementationName);
            implementation = Cast.uncheckedNonnullCast(instantiatorFactory.inject(serviceRegistry).newInstance(workerImplementation));
        } catch (Exception e) {
            failure = e;
        }

        if (failure == null) {

            if (handler instanceof Dispatch) {
                dispatch = Cast.uncheckedNonnullCast(handler);
            } else {
                dispatch = DISCARD;
            }
            BoundedDispatch<Object> boundedDispatch;
            if (dispatch instanceof BoundedDispatch) {
                boundedDispatch = Cast.uncheckedNonnullCast(dispatch);
            } else {
                boundedDispatch = DISCARD;