add set_type to ir.Value

[rkayaith]

makes sense to me

mlir/include/mlir-c/IR.h

 
 /// Returns the position of the value in the list of results of the operation
 /// that produced it.
 MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value);
 
 /// Returns the type of the value.
 MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value);
 
+/// Set the type of the value.
+MLIR_CAPI_EXPORTED void mlirValueSetType(MlirValue value, MlirType type);
+
 /// Prints the value to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value);
 
 /// Prints a value by sending chunks of the string representation and
 /// forwarding `userData to `callback`. Note that the callback may be called
 /// several times with consecutive chunks of the string.
 MLIR_CAPI_EXPORTED void
 mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData);

mlir/lib/Bindings/Python/IRCore.cpp

py::class_<PyValue>(m, "Value", py::module_local())
                                     printAccum.getUserData());
             mlirOpPrintingFlagsDestroy(flags);
             return printAccum.join();
           },
           py::arg("use_local_scope") = false, kGetNameAsOperand)
       .def_property_readonly(
           "type", [](PyValue &self) { return mlirValueGetType(self.get()); })
       .def(
+          "set_type",
+          [](PyValue &self, const PyType &type) {
+            return mlirValueSetType(self.get(), type);
+          },
+          py::arg("type"))
+      .def(
           "replace_all_uses_with",
           [](PyValue &self, PyValue &with) {
             mlirValueReplaceAllUsesOfWith(self.get(), with.get());
           },
           kValueReplaceAllUsesWithDocstring);
   PyBlockArgument::bind(m);
   PyOpResult::bind(m);
   PyOpOperand::bind(m);

mlir/lib/CAPI/IR/IR.cpp

intptr_t mlirOpResultGetResultNumber(MlirValue value) {
   return static_cast<intptr_t>(
       llvm::cast<OpResult>(unwrap(value)).getResultNumber());
 }
 
 MlirType mlirValueGetType(MlirValue value) {
   return wrap(unwrap(value).getType());
 }
 
+void mlirValueSetType(MlirValue value, MlirType type) {
+  unwrap(value).setType(unwrap(type));
+}
+
 void mlirValueDump(MlirValue value) { unwrap(value).dump(); }
 
 void mlirValuePrint(MlirValue value, MlirStringCallback callback,
                     void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(value).print(stream);
 }
 

mlir/test/python/ir/value.py

with Location.unknown(ctx):
         # CHECK:     return
         # CHECK:   }
         # CHECK: }
         print(module)
 
         value2.owner.detach_from_parent()
         # CHECK: %0
         print(value2.get_name())
+
+
+# CHECK-LABEL: TEST: testValueSetType
+@run
+def testValueSetType():
+    ctx = Context()
+    ctx.allow_unregistered_dialects = True
+    with Location.unknown(ctx):
+        i32 = IntegerType.get_signless(32)
+        i64 = IntegerType.get_signless(64)
+        module = Module.create()
+        with InsertionPoint(module.body):
+            value = Operation.create("custom.op1", results=[i32]).results[0]
+            # CHECK: Value(%[[VAL1:.*]] = "custom.op1"() : () -> i32)
+            print(value)
+
+            value.set_type(i64)
+            # CHECK: Value(%[[VAL1]] = "custom.op1"() : () -> i64)
+            print(value)
+
+            # CHECK: %[[VAL1]] = "custom.op1"() : () -> i64
+            print(value.owner)