}
	ptr = ir.NewUnaryExpr(base.Pos, ir.OSPTR, n)
	if n.Type().IsString() {
		ptr.SetType(types.Types[types.TUINT8].PtrTo())
	} else {
		ptr.SetType(n.Type().Elem().PtrTo())
	}
	ptr.SetTypecheck(1)
	length = ir.NewUnaryExpr(base.Pos, ir.OLEN, n)
	length.SetType(types.Types[types.TINT])
	length.SetTypecheck(1)
	return ptr, length
}

			n.SetType(nil)
			return n
		}
		if !n.Y.Type().IsBoolean() {
			base.Errorf("invalid operation: %v (operator %v not defined on %s)", n, n.Op(), typekind(n.Y.Type()))
			n.SetType(nil)
			return n
		}
		l, r, t := tcArith(n, n.Op(), n.X, n.Y)
		n.X, n.Y = l, r
		n.SetType(t)
		return n

	// shift operators
	case ir.OLSH, ir.ORSH:

    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 {

     */
    public void testSet() throws Exception {
        final Method m1 = SetType.class.getMethod("setOfString");
        final Type t1 = m1.getGenericReturnType();
        assertThat(GenericsUtil.isTypeOf(t1, Set.class), is(true));
        assertThat(GenericsUtil.getElementTypeOfSet(t1), is(sameClass(String.class)));

        final Method m2 = SetType.class.getMethod("setOfClass");
        final Type t2 = m2.getGenericReturnType();

      |... contents of file2.gif ...
      |--BbC04y--
      |
      |--AaB03x--
      |
      """.trimMargin().replace("\n", "\r\n")
    val body =
      MultipartBody.Builder("AaB03x")
        .setType(MultipartBody.FORM)
        .addFormDataPart("submit-name", "Larry")
        .addFormDataPart(
          "files",
          null,
          MultipartBody.Builder("BbC04y")
            .addPart(

        }
    }

    protected SitemapSet parseTextSitemaps(final InputStream in) {
        final SitemapSet sitemapSet = new SitemapSet();
        sitemapSet.setType(SitemapSet.URLSET);

        try {
            final BufferedReader br = new BufferedReader(new InputStreamReader(in, Constants.UTF_8));
            String line;
            while ((line = br.readLine()) != null) {

      arg.setType(ReplaceElementType(arg.getType(), element_type));
    }

    for (Operation& op : region.getOps()) {
      for (Value operand : op.getOperands()) {
        operand.setType(ReplaceElementType(operand.getType(), element_type));
      }

      for (Value result : op.getResults()) {
        result.setType(ReplaceElementType(result.getType(), element_type));
      }
    }
  }

    op.getResult().setType(conv_result_type);

    squeeze_op.getResult().setType(bts_op.getOutput().getType());

    // Connect `biasadd_op` with the output of `squeeze_op`.
    if (biasadd_op) {
      biasadd_op.setOperand(0, squeeze_op.getOutput());
      biasadd_op.getOutput().setType(squeeze_op.getOutput().getType());
    }
  } else {
    if (biasadd_op) biasadd_op.setOperand(0, op.getOutput());

    auto ranked_type = mlir::dyn_cast<RankedTensorType>(input.getType());
    if (!ranked_type) return false;
    auto input_shape = ranked_type.getShape();
    auto space_to_depth =
        BuildSpaceToDepth(cluster_func, input, block_size, input_shape);
    entry.value().set(space_to_depth);
    block_arg.setType(space_to_depth.getType());
  }
  return true;
}

      Value handle = tensor_array_v3_op.getHandle();
      auto handle_type = mlir::cast<TensorType>(handle.getType());
      if (handle_type.getElementType().isInteger(/*width=*/32)) {
        Type resource_tensor_type =
            handle_type.clone(TF::ResourceType::get(rewriter.getContext()));
        handle.setType(resource_tensor_type);
      }
    }

    // Special type fixes for scalar tensor types.