Apply suggestions from code review

Co-authored-by: Andy Kaylor <[email protected]>
Co-authored-by: Henrich Lauko <[email protected]>

Author: 3 people

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -360,8 +360,7 @@ void CIRGenFunction::emitCXXAggrConstructorCall(
     cgm.errorNYI(e->getSourceRange(), "dynamic-length array expression");
   }
 
-  auto arrayTy = mlir::dyn_cast<cir::ArrayType>(arrayBase.getElementType());
-  assert(arrayTy && "expected array type");
+  auto arrayTy = mlir::cast<cir::ArrayType>(arrayBase.getElementType());
   mlir::Type elementType = arrayTy.getElementType();
   cir::PointerType ptrToElmType = builder.getPointerTo(elementType);
 
@@ -400,7 +399,7 @@ void CIRGenFunction::emitCXXAggrConstructorCall(
     }
 
     // Emit the constructor call that will execute for every array element.
-    auto arrayOp = builder.createPtrBitcast(arrayBase.getPointer(), arrayTy);
+    mlir::Value arrayOp = builder.createPtrBitcast(arrayBase.getPointer(), arrayTy);
     builder.create<cir::ArrayCtor>(
         *currSrcLoc, arrayOp, [&](mlir::OpBuilder &b, mlir::Location loc) {
           auto arg = b.getInsertionBlock()->addArgument(ptrToElmType, loc);

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -845,7 +845,7 @@ CIRGenFunction::emitArrayLength(const clang::ArrayType *origArrayType,
   }
 
   baseType = eltType;
-  auto numElements = builder.getConstInt(*currSrcLoc, SizeTy, countFromCLAs);
+  cir::ConstantOp numElements = builder.getConstInt(*currSrcLoc, SizeTy, countFromCLAs);
 
   return numElements;
 }

clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp

@@ -24,30 +24,27 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> {
   void runOnOperation() override;
 
   void runOnOp(Operation *op);
-  void lowerArrayCtor(ArrayCtor op);
+  void lowerArrayCtor(cir::ArrayCtor op);
 };
 
 } // namespace
 
-void LoweringPreparePass::runOnOp(Operation *op) {
+void LoweringPreparePass::runOnOp(mlir::Operation *op) {
   if (auto arrayCtor = dyn_cast<ArrayCtor>(op)) {
     lowerArrayCtor(arrayCtor);
   }
 }
 
-static void lowerArrayDtorCtorIntoLoop(CIRBaseBuilderTy &builder,
+static void lowerArrayDtorCtorIntoLoop(cir::CIRBaseBuilderTy &builder,
                                        mlir::Operation *op, mlir::Type eltTy,
                                        mlir::Value arrayAddr,
                                        uint64_t arrayLen) {
   // Generate loop to call into ctor/dtor for every element.
-  Location loc = op->getLoc();
+  mlir::Location loc = op->getLoc();
 
   // TODO: instead of fixed integer size, create alias for PtrDiffTy and unify
   // with CIRGen stuff.
-  auto ptrDiffTy =
-      cir::IntType::get(builder.getContext(), 64, /*isSigned=*/false);
-  auto numArrayElementsConst = builder.create<cir::ConstantOp>(
-      loc, ptrDiffTy, cir::IntAttr::get(ptrDiffTy, arrayLen));
+  cir::ConstantOp numArrayElementsConst = builder.getUnsignedInt(loc, 64, arrayLen);
 
   auto begin = builder.create<cir::CastOp>(
       loc, eltTy, cir::CastKind::array_to_ptrdecay, arrayAddr);
@@ -73,8 +70,8 @@ static void lowerArrayDtorCtorIntoLoop(CIRBaseBuilderTy &builder,
       [&](mlir::OpBuilder &b, mlir::Location loc) {
         auto currentElement = b.create<cir::LoadOp>(loc, eltTy, tmpAddr);
 
-        CallOp ctorCall;
-        op->walk([&](CallOp c) { ctorCall = c; });
+        cir::CallOp ctorCall;
+        op->walk([&](cir::CallOp c) { ctorCall = c; });
         assert(ctorCall && "expected ctor call");
 
         auto one = builder.create<cir::ConstantOp>(
@@ -94,23 +91,23 @@ static void lowerArrayDtorCtorIntoLoop(CIRBaseBuilderTy &builder,
   op->erase();
 }
 
-void LoweringPreparePass::lowerArrayCtor(ArrayCtor op) {
-  CIRBaseBuilderTy builder(getContext());
+void LoweringPreparePass::lowerArrayCtor(cir::ArrayCtor op) {
+  cir::CIRBaseBuilderTy builder(getContext());
   builder.setInsertionPointAfter(op.getOperation());
 
-  Type eltTy = op->getRegion(0).getArgument(0).getType();
+  mlir::Type eltTy = op->getRegion(0).getArgument(0).getType();
   auto arrayLen =
       mlir::cast<cir::ArrayType>(op.getAddr().getType().getPointee()).getSize();
   lowerArrayDtorCtorIntoLoop(builder, op, eltTy, op.getAddr(), arrayLen);
 }
 
 void LoweringPreparePass::runOnOperation() {
-  Operation *op = getOperation();
+  mlir::Operation *op = getOperation();
 
-  llvm::SmallVector<Operation *> opsToTransform;
+  llvm::SmallVector<mlir::Operation *> opsToTransform;
 
-  op->walk([&](Operation *op) {
-    if (isa<ArrayCtor>(op)) {
+  op->walk([&](mlir::Operation *op) {
+    if (mlir::isa<cir::ArrayCtor>(op)) {
       opsToTransform.push_back(op);
     }
   });