visitor.candidate("Maps");
    }

    @Override
    public T parseType(Map values) throws UnsupportedNotationException {
        Map<String, Object> mutableValues = new HashMap<>(Cast.uncheckedNonnullCast(values));
        Set<String> missing = null;
        ConvertMethod convertMethod = null;
        Method method = null;
        while (method == null) {
            convertMethod = ConvertMethod.of(this.getClass());

        return type;
    }

    @Override
    public void setFromAnyValue(Object object) {
        if (object instanceof Provider) {
            set(Cast.<Provider<T>>uncheckedNonnullCast(object));
        } else {
            set(Cast.<T>uncheckedNonnullCast(object));
        }
    }

    @Override
    public void set(@Nullable T value) {
        if (value == null) {
            discardValue();
        } else {

            }
            return super.add(wrap(Cast.uncheckedNonnullCast(action)));
        }

        @Override
        public void add(int index, Object action) {
            if (action == null) {
                throw new InvalidUserDataException("Action must not be null!");
            }
            super.add(index, wrap(Cast.uncheckedNonnullCast(action)));
        }

        @Override

 */
public class TypeInfo<T> {
    private final Class<T> targetType;

    public TypeInfo(Class<?> targetType) {
        assert targetType != null;
        this.targetType = Cast.uncheckedNonnullCast(targetType);
    }

    public Class<T> getTargetType() {
        return targetType;
    }

            }
            return Cast.uncheckedNonnullCast(typeInfo.serializer.read(decoder));
        }

        @Override
        public void write(Encoder encoder, T value) throws Exception {
            TypeInfo typeInfo = map(value.getClass());
            encoder.writeSmallInt(typeInfo.tag);
            Cast.<Serializer<T>>uncheckedNonnullCast(typeInfo.serializer).write(encoder, value);
        }

 * limitations under the License.
 */

package org.gradle.internal.extensions.stdlib

import org.gradle.internal.Cast


fun <T> Any.uncheckedCast(): T =

    }

    @Override
    public <T extends Authentication> Map<Class<T>, Class<? extends T>> getRegisteredSchemes() {
        return Collections.unmodifiableMap(Cast.uncheckedNonnullCast(registeredSchemes));
    }

        }
    }

    private <T> void onComplete(Object result, @Nullable IntermediateResultHandler<T> handler) {
        if (handler != null) {
            handler.onComplete(Cast.<T>uncheckedNonnullCast(result));
        }
    }

        return Cast.uncheckedNonnullCast(getInstantiator().newInstance(DefaultNamedDomainObjectSet.class, this, filter, getInstantiator(), getNamer(), crossProjectConfiguratorMutationGuard));
    }

    @Override
    protected <S extends T> DefaultNamedDomainObjectSet<S> filtered(Spec<String> nameFilter, CollectionFilter<S> elementFilter) {

    }

    @Override
    public Set<T> parseNotation(N notation) {
        Collection<N> notations = Cast.uncheckedNonnullCast(GUtil.collectionize(notation));
        if (notations.isEmpty()) {
            return Collections.emptySet();
        }
        if (notations.size() == 1) {