Object results = connection.run(action, buildCancellationToken, providerParameters);
        return new ProviderBuildResult<>(Cast.uncheckedNonnullCast(results));
    }

    /**
     * This is used by consumers 4.4 and later
     */
    @Override

        @SafeVarargs
        @Nullable
        static <T> SideEffect<T> composite(SideEffect<? super T>... sideEffects) {
            @SuppressWarnings("varargs")
            List<SideEffect<T>> sideEffectList = Cast.uncheckedNonnullCast(Arrays.asList(sideEffects));
            return CompositeSideEffect.of(sideEffectList);
        }

        /**

            setSupplier(new FixedSupplier<>(value.getFixedValue(), Cast.uncheckedCast(value.getSideEffect())));
        } else {
            CollectingProvider<T, C> asCollectingProvider = Cast.uncheckedNonnullCast(value.getChangingValue());
            setSupplier(new CollectingSupplier(new ElementsFromCollectionProvider<>(asCollectingProvider)));
        }
    }

    @Override

            this.provider = ignoreAbsent ? neverMissing(Cast.uncheckedNonnullCast(provider)) : provider;
            this.ignoreAbsent = ignoreAbsent;
        }

        @Nonnull
        private static <T> ProviderInternal<? extends Iterable<? extends T>> neverMissing(ProviderInternal<Iterable<? extends T>> provider) {
            return Cast.uncheckedNonnullCast(provider.orElse(ImmutableList.of()));
        }

        @Override

            setSupplier(noValueSupplier());
        } else if (value.hasFixedValue()) {
            setSupplier(new FixedSupplier<>(uncheckedNonnullCast(value.getFixedValue()), uncheckedCast(value.getSideEffect())));
        } else {
            CollectingProvider<K, V> asCollectingProvider = uncheckedNonnullCast(value.getChangingValue());
            setSupplier(new CollectingSupplier(new EntriesFromMapProvider<>(asCollectingProvider)));
        }

        Class<? extends BuildCacheServiceFactory<C>> castFactoryType = Cast.uncheckedNonnullCast(
            buildCacheConfiguration.getBuildCacheServiceFactoryType(configuration.getClass())
        );

        BuildCacheServiceFactory<C> factory = instantiator.newInstance(castFactoryType);
        Describer describer = new Describer();
        S service = Cast.uncheckedNonnullCast(factory.createBuildCacheService(configuration, describer));

        private Failure(String reason) {
            this.reason = reason;
        }
    }

    private static final Class<? extends Annotation>[] CALLABLE_KIND_ANNOTATION_CLASSES = Cast.uncheckedNonnullCast(new Class<?>[]{
        CallableKind.InstanceMethod.class,
        CallableKind.StaticMethod.class,
        CallableKind.AfterConstructor.class,
        CallableKind.GroovyPropertyGetter.class,

    }

    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,

        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) {