[MooreToCore] Add support for lowering moore.class.upcast

- Added `ClassUpcastOpConversion` lowering:
  - Converts `moore.class.upcast` to a direct value forward when both source and
    destination are LLVM opaque pointers (`!llvm.ptr`).
  - Emits a diagnostic if applied to non-opaque pointer types.

- Registered the new pattern in `populateOpConversion` alongside other class
  conversion patterns.

Author: Scheremo

lib/Conversion/MooreToCore/MooreToCore.cpp

@@ -707,6 +707,29 @@ static Value createZeroValue(Type type, Location loc,
   return rewriter.createOrFold<hw::BitcastOp>(loc, type, constZero);
 }
 
+struct ClassUpcastOpConversion : public OpConversionPattern<ClassUpcastOp> {
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(ClassUpcastOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    // Expect lowered types like !llvm.ptr
+    Type dstTy = getTypeConverter()->convertType(op.getResult().getType());
+    Type srcTy = adaptor.getInstance().getType();
+
+    if (!dstTy)
+      return rewriter.notifyMatchFailure(op, "failed to convert result type");
+
+    // If the types are already identical (opaque pointer mode), just forward.
+    if (dstTy == srcTy && isa<LLVM::LLVMPointerType>(srcTy)) {
+      rewriter.replaceOp(op, adaptor.getInstance());
+      return success();
+    }
+    return rewriter.notifyMatchFailure(
+        op, "Upcast applied to non-opaque pointers!");
+  }
+};
+
 /// moore.class.new lowering: heap-allocate storage for the class object.
 struct ClassNewOpConversion : public OpConversionPattern<ClassNewOp> {
   ClassNewOpConversion(TypeConverter &tc, MLIRContext *ctx,
@@ -2156,6 +2179,7 @@ static void populateOpConversion(ConversionPatternSet &patterns,
                                      classCache);
   // clang-format off
   patterns.add<
+    ClassUpcastOpConversion,
     // Patterns of declaration operations.
     VariableOpConversion,
     NetOpConversion,

test/Conversion/MooreToCore/classes.mlir

@@ -80,3 +80,23 @@ moore.class.classdecl @E extends @C {
   moore.class.propertydecl @b : !moore.l32
   moore.class.propertydecl @c : !moore.l32
 }
+
+/// Check that upcast lowers to no-op
+
+// CHECK-LABEL: func.func private @test_new5
+// CHECK-SAME: (%arg0: !llvm.ptr) {
+// CHECK:   return
+
+// CHECK-NOT: moore.class.new
+// CHECK-NOT: moore.class.upcast
+// CHECK-NOT: moore.class.classdecl
+
+func.func private @test_new5(%arg0: !moore.class<@F>) {
+  %upcast = moore.class.upcast %arg0 : <@F> to <@C>
+  return
+}
+moore.class.classdecl @F extends @C {
+  moore.class.propertydecl @a : !moore.i32
+  moore.class.propertydecl @b : !moore.l32
+  moore.class.propertydecl @c : !moore.l32
+}