*
     * @param outputType The type to cast the input to
     * @param object The object to be cast (must not be {@code null})
     * @param <O> The type to be cast to
     * @param <I> The type of the object to be vast
     * @return The input object, cast to the output type
     */
    public static <O, I> O cast(Class<O> outputType, I object) {
        try {

package org.gradle.internal

import spock.lang.Specification

import static Cast.cast

class CastTest extends Specification {

    def "casting"() {
        given:
        def arg = "1"

        when:
        cast(Integer, arg)

        then:
        def e = thrown(ClassCastException)
        e.message == "Failed to cast object $arg of type ${arg.class.name} to target type ${Integer.name}"

        when:

  auto input_args_have_static_shape = [&]() -> bool {
    return mlir::cast<TensorType>(input_tensor.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(kernel_tensor.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(window_strides.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(padding.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(lhs_dilation.getType()).hasStaticShape() &&

// division can result in strange behavior.
//
//      floordiv = cast(floordiv(cast(left), cast(right))))
//
//   %left_cast = cast(%left)
//   %right_cast = cast(%right)
//   %div = div(%left, %left)
//   %floored = floor(%div)
//   %floored_cast = cast(%floored)
//
// Required to manually specify the intermediate types.

        /*
         * We have an Iterator<E> and want to cast it to
         * MultiExceptionListIterator. Because we're inside an
         * AbstractIteratorTester<E>, that's implicitly a cast to
         * AbstractIteratorTester<E>.MultiExceptionListIterator. The runtime
         * won't be able to verify the AbstractIteratorTester<E> part, so it's
         * an unchecked cast. We know, however, that the only possible value for

        /*
         * We have an Iterator<E> and want to cast it to
         * MultiExceptionListIterator. Because we're inside an
         * AbstractIteratorTester<E>, that's implicitly a cast to
         * AbstractIteratorTester<E>.MultiExceptionListIterator. The runtime
         * won't be able to verify the AbstractIteratorTester<E> part, so it's
         * an unchecked cast. We know, however, that the only possible value for

 */
package org.gradle.tooling.internal.provider;

import org.gradle.initialization.BuildCancellationToken;
import org.gradle.initialization.BuildLayoutParameters;
import org.gradle.internal.Cast;
import org.gradle.internal.buildprocess.BuildProcessState;
import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.deprecation.DeprecationLogger;
import org.gradle.internal.instrumentation.agent.AgentStatus;

  // mapping from original operand to new XlaAllReduce op.
  llvm::DenseMap<Value, Value> orig_to_new;

  for (Value bcast : bcasts) {
    if (failed(MoveBroadcastToCluster(builder, inner_builder, cluster,
                                      replicate, orig_to_new, bcast, module))) {
      return failure();
    }
  }

  cluster->walk([&](Operation* op) {

			v = AppendValidation(v, fmt.Errorf("invalid gateway name: %q", name))
		}
		value, ok := cfg.Spec.(*networking.Gateway)
		if !ok {
			v = AppendValidation(v, fmt.Errorf("cannot cast to gateway: %#v", cfg.Spec))
			return v.Unwrap()
		}

		if len(value.Servers) == 0 {
			v = AppendValidation(v, fmt.Errorf("gateway must have at least one server"))
		} else {

                }
            }

            is KtBinaryExpressionWithTypeRHS -> {
                val typeReference = parentExpression.right
                if (KtPsiUtil.isCast(parentExpression) && typeReference != null) {
                    val bindingContext = analysisContext.analyze(typeReference)
                    var kotlinType = bindingContext[BindingContext.TYPE, typeReference]