@Nullable
    public static <T> T uncheckedCast(@Nullable Object object) {
        return (T) object;
    }

    @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
    public static <T> T uncheckedNonnullCast(Object object) {
        return (T) object;
    }

        taskMutator.mutate("Task.usesService(Provider)", () -> {
            // TODO:configuration-cache assert build service is from the same build as the task
            addRegisteredService(Cast.uncheckedNonnullCast(service));
        });
    }

    private void addRegisteredService(RegisteredBuildServiceProvider<?, ?> service) {
        if (registeredServices == null) {

        R result = execute(work, context);
        return new DefaultIdentityCacheResult<>(
            result
                .getOutputAs(Object.class)
                .map(Cast::<T>uncheckedNonnullCast),
            result
                .getReusedOutputOriginMetadata()
                .orElseGet(() -> result.getAfterExecutionOutputState()
                    .map(ExecutionOutputState::getOriginMetadata)

    }

    public BroadcastDispatch<T> add(String methodName, Action<?> action) {
        assertIsMethod(methodName);
        return add(action, new ActionInvocationHandler(methodName, Cast.<Action<Object>>uncheckedNonnullCast(action)));
    }

    abstract BroadcastDispatch<T> add(Object handler, Dispatch<MethodInvocation> dispatch);

    private void assertIsMethod(String methodName) {
        for (Method method : type.getMethods()) {

    ) throws IOException {
        if (optionsAllowReading(options)) {
            tryReportFileOpened(path, consumer);
        }
        return Files.newByteChannel(path, Cast.uncheckedNonnullCast(options), attrs);
    }

    @InterceptCalls
    @StaticMethod(ofClass = Files.class)
    public static BufferedReader intercept_newBufferedReader(
        Path path,

        }

        @Override
        public <N extends S> CollectionEventRegister<N> filtered(CollectionFilter<N> filter) {
            return new FilteredEventRegister<N>(filter, Cast.uncheckedNonnullCast(this));
        }
    }

        ModelType<?> propertyType = ModelType.of(propertyMetadata.getDeclaredType().getType());
        List<ModelType<?>> typeVariables = Cast.uncheckedNonnullCast(propertyType.getTypeVariables());
        if (typeVariables.size() != 1 || !BuildService.class.isAssignableFrom(typeVariables.get(0).getRawClass())) {
            validationContext.visitPropertyProblem(problem ->

        final Element<T> element = new Element<>(provider.getType(), new ElementFromProvider<>(provider), this::doAddRealized);
        if (provider instanceof ChangingValue) {
            Cast.<ChangingValue<T>>uncheckedNonnullCast(provider).onValueChange(previousValue -> clearCachedElement(element));
        }
        return element;
    }

    Element<T> cachingElement(CollectionProviderInternal<T, ? extends Iterable<T>> provider) {

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