// If we want a type but don't have one, stop right here and avoid potential problems
	// with missing underlying types. This also gives better error messages in some cases
	// (see go.dev/issue/65344).
	_, gotType := obj.(*TypeName)
	if !gotType && wantType {
		check.errorf(e, NotAType, "%s is not a type", obj.Name())
		// avoid "declared but not used" errors
		// (don't use Checker.use - we don't want to evaluate too much)

	// If we want a type but don't have one, stop right here and avoid potential problems
	// with missing underlying types. This also gives better error messages in some cases
	// (see go.dev/issue/65344).
	_, gotType := obj.(*TypeName)
	if !gotType && wantType {
		check.errorf(e, NotAType, "%s is not a type", obj.Name())
		// avoid "declared but not used" errors
		// (don't use Checker.use - we don't want to evaluate too much)

		return tInt.gobType(), nil

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return tUint.gobType(), nil

	case reflect.Float32, reflect.Float64:
		return tFloat.gobType(), nil

	case reflect.Complex64, reflect.Complex128:
		return tComplex.gobType(), nil

	case reflect.String:
		return tString.gobType(), nil

	case reflect.Interface:

  if (!reshape_before) return failure();

  if (!dot.getLhs().getType().hasStaticShape() ||
      !dot.getRhs().getType().hasStaticShape() ||
      !reshape_before.getOperand().getType().hasStaticShape() ||
      !dot.getType().hasStaticShape() ||
      !reshape_after.getType().hasStaticShape()) {
    return rewriter.notifyMatchFailure(reshape_after,

            getType(Project.class),
            getType("Lorg/gradle/api/internal/project/ProjectInternal;"),
            getType(Gradle.class),
            getType("Lorg/gradle/api/internal/GradleInternal;")
        );
        private static final Type JAVA_LANG_REFLECT_TYPE = getType(java.lang.reflect.Type.class);
        private static final Type OBJECT_TYPE = getType(Object.class);

    if (!inner_reshape_op.getOutput().getType().hasStaticShape() ||
        !tfl_broadcast_to_op.getOutput().getType().hasStaticShape() ||
        !outer_reshape_op.getOutput().getType().hasStaticShape()) {
      return rewriter.notifyMatchFailure(
          loc, "Unsupported shapes. Currely only static shapes are supported");
    }

    if (!IsLastDimEqualToNumElements(inner_reshape_input.getType(),

  // Hybrid lookup is not supported.
  if (value_attr.getType().getElementType() != getType().getElementType()) {
    return {};
  }

  // Expect 1d lookup tensor and a non-scalar input.
  if (lookup_attr.getType().getRank() != 1 ||
      value_attr.getType().getRank() == 0) {
    return {};
  }

  int64_t outer_dim_size = value_attr.getType().getShape()[0];

    if (!mlir::cast<ShapedType>(lhs.getType()).hasStaticShape() ||
        !mlir::cast<ShapedType>(rhs.getType()).hasStaticShape() ||
        !mlir::cast<ShapedType>(cond.getType()).hasStaticShape()) {
      return rewriteOpWithDynamicInput(op, rewriter);
    }

    auto lhs_shape = mlir::cast<ShapedType>(lhs.getType()).getShape();
    auto rhs_shape = mlir::cast<ShapedType>(rhs.getType()).getShape();

    for (auto [call_arg, body_arg] :
         llvm::zip(call.getOperation()->getOperands(),
                   f.getBody().front().getArguments())) {
      if (call_arg.getType() != body_arg.getType()) {
        body_arg.setType(call_arg.getType());
        changed = true;
      }
    }
    if (changed) {
      rewriter.finalizeOpModification(f);
      return success();
    } else {

  if (!converter.isLegal(convert_op.getOperand().getType())) {
    auto other_convert_op = dyn_cast_or_null<OtherConvertOp>(
        convert_op.getOperand().getDefiningOp());
    return other_convert_op &&
           converter.isLegal(other_convert_op.getOperand().getType());
  } else if (!converter.isLegal(convert_op.getResult().getType())) {
    if (!convert_op.getResult().hasOneUse()) {
      return false;
    }