diff --git a/mlir/lib/Dialect/Arith/Utils/CMakeLists.txt b/mlir/lib/Dialect/Arith/Utils/CMakeLists.txt
--- a/mlir/lib/Dialect/Arith/Utils/CMakeLists.txt
+++ b/mlir/lib/Dialect/Arith/Utils/CMakeLists.txt
@@ -6,6 +6,7 @@
 
   LINK_LIBS PUBLIC
   MLIRArithDialect
+  MLIRComplexDialect
   MLIRDialect
   MLIRIR
   )
diff --git a/mlir/lib/Dialect/Arith/Utils/Utils.cpp b/mlir/lib/Dialect/Arith/Utils/Utils.cpp
--- a/mlir/lib/Dialect/Arith/Utils/Utils.cpp
+++ b/mlir/lib/Dialect/Arith/Utils/Utils.cpp
@@ -12,6 +12,8 @@
 
 #include "mlir/Dialect/Arith/Utils/Utils.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/Complex/IR/Complex.h"
+#include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 using namespace mlir;
@@ -84,45 +86,118 @@
   return b.create<arith::TruncIOp>(loc, targetIntegerType, value);
 }
 
-Value mlir::convertScalarToDtype(OpBuilder &b, Location loc, Value operand,
-                                 Type toType, bool isUnsignedCast) {
-  if (operand.getType() == toType)
-    return operand;
-  if (auto toIntType = dyn_cast<IntegerType>(toType)) {
-    // If operand is floating point, cast directly to the int type.
-    if (isa<FloatType>(operand.getType())) {
-      if (isUnsignedCast)
-        return b.create<arith::FPToUIOp>(loc, toType, operand);
-      return b.create<arith::FPToSIOp>(loc, toType, operand);
+static Value convertToTargetInt(ImplicitLocOpBuilder &b, Value operand,
+                                IntegerType toType, bool isUnsigned) {
+  // If operand is floating point, cast directly to the int type.
+  if (isa<FloatType>(operand.getType())) {
+    if (isUnsigned)
+      return b.create<arith::FPToUIOp>(toType, operand);
+    return b.create<arith::FPToSIOp>(toType, operand);
+  }
+  // Cast index operands directly to the int type.
+  if (operand.getType().isIndex())
+    return b.create<arith::IndexCastOp>(toType, operand);
+  if (auto fromIntType = dyn_cast<IntegerType>(operand.getType())) {
+    // Either extend or truncate.
+    if (toType.getWidth() > fromIntType.getWidth()) {
+      if (isUnsigned)
+        return b.create<arith::ExtUIOp>(toType, operand);
+      return b.create<arith::ExtSIOp>(toType, operand);
     }
-    // Cast index operands directly to the int type.
-    if (operand.getType().isIndex())
-      return b.create<arith::IndexCastOp>(loc, toType, operand);
-    if (auto fromIntType = dyn_cast<IntegerType>(operand.getType())) {
-      // Either extend or truncate.
-      if (toIntType.getWidth() > fromIntType.getWidth()) {
-        if (isUnsignedCast)
-          return b.create<arith::ExtUIOp>(loc, toType, operand);
-        return b.create<arith::ExtSIOp>(loc, toType, operand);
+    if (toType.getWidth() < fromIntType.getWidth())
+      return b.create<arith::TruncIOp>(toType, operand);
+  }
+
+  return {};
+}
+
+static Value convertToTargetFp(ImplicitLocOpBuilder &b, Value operand,
+                               FloatType toType, bool isUnsigned) {
+  // If operand is integer, cast directly to the float type.
+  // Note that it is unclear how to cast from BF16<->FP16.
+  if (isa<IntegerType>(operand.getType())) {
+    if (isUnsigned)
+      return b.create<arith::UIToFPOp>(toType, operand);
+    return b.create<arith::SIToFPOp>(toType, operand);
+  }
+  if (auto fromFpTy = dyn_cast<FloatType>(operand.getType())) {
+    if (toType.getWidth() > fromFpTy.getWidth())
+      return b.create<arith::ExtFOp>(toType, operand);
+    if (toType.getWidth() < fromFpTy.getWidth())
+      return b.create<arith::TruncFOp>(toType, operand);
+  }
+
+  return {};
+}
+
+static Value convertToTargetComplex(ImplicitLocOpBuilder &b, Value operand,
+                                    ComplexType targetType, bool isUnsigned) {
+  if (auto fromComplexType = dyn_cast<ComplexType>(operand.getType())) {
+    if (isa<FloatType>(targetType.getElementType()) &&
+        isa<FloatType>(fromComplexType.getElementType())) {
+      Value real = b.create<complex::ReOp>(operand);
+      Value imag = b.create<complex::ImOp>(operand);
+      Type targetETy = targetType.getElementType();
+      if (targetType.getElementType().getIntOrFloatBitWidth() <
+          fromComplexType.getElementType().getIntOrFloatBitWidth()) {
+        real = b.create<arith::TruncFOp>(targetETy, real);
+        imag = b.create<arith::TruncFOp>(targetETy, imag);
+      } else {
+        real = b.create<arith::ExtFOp>(targetETy, real);
+        imag = b.create<arith::ExtFOp>(targetETy, imag);
       }
-      if (toIntType.getWidth() < fromIntType.getWidth())
-        return b.create<arith::TruncIOp>(loc, toType, operand);
+      return b.create<complex::CreateOp>(targetType, real, imag);
     }
-  } else if (auto toFloatType = dyn_cast<FloatType>(toType)) {
-    // If operand is integer, cast directly to the float type.
-    // Note that it is unclear how to cast from BF16<->FP16.
-    if (isa<IntegerType>(operand.getType())) {
-      if (isUnsignedCast)
-        return b.create<arith::UIToFPOp>(loc, toFloatType, operand);
-      return b.create<arith::SIToFPOp>(loc, toFloatType, operand);
+  }
+
+  if (auto fromFpType = dyn_cast<FloatType>(operand.getType())) {
+    FloatType toFpTy = cast<FloatType>(targetType.getElementType());
+    auto toBitwidth = toFpTy.getIntOrFloatBitWidth();
+    Value from = operand;
+    if (from.getType().getIntOrFloatBitWidth() < toBitwidth) {
+      from = b.create<arith::ExtFOp>(toFpTy, from);
+    }
+    if (from.getType().getIntOrFloatBitWidth() > toBitwidth) {
+      from = b.create<arith::TruncFOp>(toFpTy, from);
     }
-    if (auto fromFloatType = dyn_cast<FloatType>(operand.getType())) {
-      if (toFloatType.getWidth() > fromFloatType.getWidth())
-        return b.create<arith::ExtFOp>(loc, toFloatType, operand);
-      if (toFloatType.getWidth() < fromFloatType.getWidth())
-        return b.create<arith::TruncFOp>(loc, toFloatType, operand);
+    Value zero = b.create<mlir::arith::ConstantFloatOp>(
+        mlir::APFloat(toFpTy.getFloatSemantics(), 0), toFpTy);
+    return b.create<complex::CreateOp>(targetType, from, zero);
+  }
+
+  if (auto fromIntType = dyn_cast<IntegerType>(operand.getType())) {
+    FloatType toFpTy = cast<FloatType>(targetType.getElementType());
+    Value from = operand;
+    if (isUnsigned) {
+      from = b.create<arith::UIToFPOp>(toFpTy, from);
+    } else {
+      from = b.create<arith::SIToFPOp>(toFpTy, from);
     }
+    Value zero = b.create<mlir::arith::ConstantFloatOp>(
+        mlir::APFloat(toFpTy.getFloatSemantics(), 0), toFpTy);
+    return b.create<complex::CreateOp>(targetType, from, zero);
+  }
+
+  return {};
+}
+
+Value mlir::convertScalarToDtype(OpBuilder &b, Location loc, Value operand,
+                                 Type toType, bool isUnsignedCast) {
+  if (operand.getType() == toType)
+    return operand;
+  ImplicitLocOpBuilder ib(loc, b);
+  Value result;
+  if (auto intTy = dyn_cast<IntegerType>(toType)) {
+    result = convertToTargetInt(ib, operand, intTy, isUnsignedCast);
+  } else if (auto floatTy = dyn_cast<FloatType>(toType)) {
+    result = convertToTargetFp(ib, operand, floatTy, isUnsignedCast);
+  } else if (auto complexTy = dyn_cast<ComplexType>(toType)) {
+    result = convertToTargetComplex(ib, operand, complexTy, isUnsignedCast);
   }
+
+  if (result)
+    return result;
+
   emitWarning(loc) << "could not cast operand of type " << operand.getType()
                    << " to " << toType;
   return operand;