[MooreToCore] Implement ClassDeclOp -> LLVMStructType conversion

Add support for converting `moore.class.classdecl` operations into
identified LLVM struct types during the MooreToCore lowering.

- Introduced **`ClassTypeCache`** for mapping class symbols to LLVM structs and field paths.
- Added utilities:
  - `mangleClassName` generates `moore.class.<name>` identifiers.
  - `getOrCreateOpaqueStruct` creates identified LLVM struct types.
- Implemented `resolveClassStructBody` to:
  - Lay out classes in **base-first** order.
  - Convert class properties to LLVM member types.
  - Inherit base field paths.
- Added `ClassDeclOpConversion` to handle class lowering and removal.
- Extended type conversion:
  - `ClassHandleType` -> `!llvm.ptr`
- Integrated cache handling into `MooreToCorePass`.

Author: Scheremo

lib/Conversion/MooreToCore/MooreToCore.cpp

@@ -48,6 +48,158 @@ using llvm::SmallDenseSet;
 
 namespace {
 
+/// Cache for identified structs and field GEP paths keyed by class symbol.
+struct ClassTypeCache {
+  struct ClassStructInfo {
+    mlir::LLVM::LLVMStructType classBody;
+
+    // field name -> GEP path inside ident (excluding the leading pointer index)
+    llvm::DenseMap<llvm::StringRef, llvm::SmallVector<unsigned, 2>>
+        propertyPath;
+
+    // TODO: Add classVTable in here.
+    bool isFinalized = false;
+
+    /// Record/overwrite the field path to a single property for a class.
+    void setFieldPath(llvm::StringRef propertyName,
+                      llvm::ArrayRef<unsigned> path) {
+      this->propertyPath[propertyName] =
+          llvm::SmallVector<unsigned, 2>(path.begin(), path.end());
+    }
+
+    /// Lookup the full GEP path for a (class, field).
+    std::optional<llvm::ArrayRef<unsigned>>
+    getFieldPath(mlir::FlatSymbolRefAttr propertySym) const {
+      if (auto prop = this->propertyPath.find(propertySym.getValue());
+          prop != this->propertyPath.end())
+        return llvm::ArrayRef<unsigned>(prop->second);
+      return std::nullopt;
+    }
+  };
+
+  /// Record the identified struct body for a class.
+  /// Implicitly finalizes the class to struct conversion.
+  void setClassBody(mlir::SymbolRefAttr classSym,
+                    mlir::LLVM::LLVMStructType &classBody) {
+    classToStructMap[classSym].classBody = classBody;
+    classToStructMap[classSym].isFinalized = true;
+  }
+
+  /// Lookup the identified struct body for a class.
+  std::optional<ClassStructInfo>
+  getStructInfo(mlir::SymbolRefAttr classSym) const {
+    if (auto it = classToStructMap.find(classSym); it != classToStructMap.end())
+      return it->second;
+    return std::nullopt;
+  }
+
+private:
+  // Keyed by the SymbolRefAttr of the class.
+  // Kept private so all accesses are done with helpers which preserve
+  // invariants
+  llvm::DenseMap<mlir::Attribute, ClassStructInfo> classToStructMap;
+};
+
+/// Helper function to create an LLVM-friendly name from a class name symbol
+/// Classname is expected to be in a H1::H2::H3::@C format.
+static std::string mangleClassName(SymbolRefAttr className) {
+  std::string s;
+  llvm::raw_string_ostream os(s);
+  // Add a constant prefix "moore.class."
+  os << "moore.class.";
+
+  StringRef root = className.getRootReference();
+  SmallVector<StringRef> parts;
+  root.split(parts, "::");
+
+  for (size_t i = 0; i < parts.size(); ++i) {
+    if (i)
+      os << '.';
+    os << parts[i];
+  }
+
+  return os.str();
+}
+
+/// Helper function to create an opaque LLVM Struct Type which corresponds
+/// to the sym
+static LLVM::LLVMStructType getOrCreateOpaqueStruct(MLIRContext *ctx,
+                                                    SymbolRefAttr className) {
+  auto name = mangleClassName(className);
+  if (auto existing = LLVM::LLVMStructType::getIdentified(ctx, name))
+    return existing;
+  return LLVM::LLVMStructType::getIdentified(ctx, name);
+}
+
+static LogicalResult resolveClassStructBody(circt::moore::ClassDeclOp op,
+                                            TypeConverter const &typeConverter,
+                                            ClassTypeCache &cache) {
+
+  auto classSym = SymbolRefAttr::get(op.getSymNameAttr());
+  auto structInfo = cache.getStructInfo(classSym);
+  if (structInfo && structInfo->isFinalized)
+    // We already have a resolved class struct body.
+    return success();
+
+  // Otherwise we need to resolve.
+  ClassTypeCache::ClassStructInfo structBody;
+  SmallVector<Type> structBodyMembers;
+
+  // Base-first (prefix) layout for single inheritance.
+  unsigned derivedStartIdx = 0;
+
+  if (auto baseClass = op.getBaseAttr()) {
+
+    // Process base class' struct layout first
+    auto baseClassStruct = cache.getStructInfo(baseClass);
+    if (!baseClassStruct || !baseClassStruct->isFinalized)
+      return op.emitOpError() << "Base class " << baseClass << " of "
+                              << classSym << " has not been converted.";
+
+    structBodyMembers.push_back(baseClassStruct->classBody);
+    derivedStartIdx = 1;
+
+    // Inherit base field paths with a leading 0.
+    for (auto &kv : baseClassStruct->propertyPath) {
+      llvm::SmallVector<unsigned, 2> path;
+      path.push_back(0); // into base subobject
+      path.append(kv.second.begin(), kv.second.end());
+      structBody.setFieldPath(kv.first, path);
+    }
+  }
+
+  // Properties in source order.
+  unsigned iterator = derivedStartIdx;
+  auto &block = op.getBody().front();
+  for (Operation &child : block) {
+    if (auto prop = dyn_cast<circt::moore::ClassPropertyDeclOp>(child)) {
+      Type mooreTy = prop.getPropertyType();
+      Type llvmTy = typeConverter.convertType(mooreTy);
+      if (!llvmTy)
+        return prop.emitOpError()
+               << "failed to convert property type " << mooreTy;
+
+      structBodyMembers.push_back(llvmTy);
+
+      // Derived field path: either {i} or {1+i} if base is present.
+      llvm::SmallVector<unsigned, 2> path{iterator};
+      structBody.setFieldPath(prop.getSymName(), path);
+      ++iterator;
+    }
+  }
+
+  // TODO: Handle vtable generation over ClassMethodDeclOp here.
+  auto llvmStructTy = getOrCreateOpaqueStruct(op.getContext(), classSym);
+  // Empty structs may be kept opaque
+  if (!structBodyMembers.empty() &&
+      failed(llvmStructTy.setBody(structBodyMembers, false)))
+    return op.emitOpError() << "Failed to set LLVM Struct body";
+
+  cache.setClassBody(classSym, llvmStructTy);
+
+  return success();
+}
+
 /// Returns the passed value if the integer width is already correct.
 /// Zero-extends if it is too narrow.
 /// Truncates if the integer is too wide and the truncated part is zero, if it
@@ -549,6 +701,26 @@ static Value createZeroValue(Type type, Location loc,
   return rewriter.createOrFold<hw::BitcastOp>(loc, type, constZero);
 }
 
+struct ClassDeclOpConversion : public OpConversionPattern<ClassDeclOp> {
+  ClassDeclOpConversion(TypeConverter &tc, MLIRContext *ctx,
+                        ClassTypeCache &cache)
+      : OpConversionPattern<ClassDeclOp>(tc, ctx), cache(cache) {}
+
+  LogicalResult
+  matchAndRewrite(ClassDeclOp op, OpAdaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    if (failed(resolveClassStructBody(op, *typeConverter, cache)))
+      return failure();
+
+    // The declaration itself is a no-op
+    rewriter.eraseOp(op);
+    return success();
+  }
+
+private:
+  ClassTypeCache &cache; // shared, owned by the pass
+};
+
 struct VariableOpConversion : public OpConversionPattern<VariableOp> {
   using OpConversionPattern::OpConversionPattern;
 
@@ -1876,6 +2048,11 @@ static void populateTypeConversion(TypeConverter &typeConverter) {
   typeConverter.addConversion(
       [](LLVM::LLVMPointerType t) -> std::optional<Type> { return t; });
 
+  // ClassHandleType  ->  !llvm.ptr
+  typeConverter.addConversion([&](ClassHandleType type) -> std::optional<Type> {
+    return mlir::LLVM::LLVMPointerType::get(type.getContext());
+  });
+
   typeConverter.addConversion([&](RefType type) -> std::optional<Type> {
     if (auto innerType = typeConverter.convertType(type.getNestedType()))
       return llhd::RefType::get(innerType);
@@ -1936,7 +2113,12 @@ static void populateTypeConversion(TypeConverter &typeConverter) {
 }
 
 static void populateOpConversion(ConversionPatternSet &patterns,
-                                 TypeConverter &typeConverter) {
+                                 TypeConverter &typeConverter,
+                                 ClassTypeCache &classCache) {
+
+  patterns.add<ClassDeclOpConversion>(typeConverter, patterns.getContext(),
+                                      classCache);
+
   // clang-format off
   patterns.add<
     // Patterns of declaration operations.
@@ -2099,6 +2281,7 @@ std::unique_ptr<OperationPass<ModuleOp>> circt::createConvertMooreToCorePass() {
 void MooreToCorePass::runOnOperation() {
   MLIRContext &context = getContext();
   ModuleOp module = getOperation();
+  ClassTypeCache classCache;
 
   IRRewriter rewriter(module);
   (void)mlir::eraseUnreachableBlocks(rewriter, module->getRegions());
@@ -2110,7 +2293,7 @@ void MooreToCorePass::runOnOperation() {
   populateLegality(target, typeConverter);
 
   ConversionPatternSet patterns(&context, typeConverter);
-  populateOpConversion(patterns, typeConverter);
+  populateOpConversion(patterns, typeConverter, classCache);
 
   if (failed(applyFullConversion(module, target, std::move(patterns))))
     signalPassFailure();

test/Conversion/MooreToCore/classes.mlir

@@ -0,0 +1,30 @@
+// RUN: circt-opt %s --convert-moore-to-core --verify-diagnostics | FileCheck %s
+
+/// Check that a classdecl gets translated to a llvm struct type
+
+// CHECK-LABEL: module {
+// CHECK: llvm.mlir.global internal @__type_PropertyCombo() {addr_space = 0 : i32}
+// CHECK-SAME: : !llvm.struct<"moore.class.PropertyCombo", (i32, i18, i32)> {
+// CHECK: [[U:%.*]] = llvm.mlir.undef : !llvm.struct<"moore.class.PropertyCombo", (i32, i18, i32)>
+// CHECK: llvm.return [[U]] : !llvm.struct<"moore.class.PropertyCombo", (i32, i18, i32)>
+// CHECK: }
+// CHECK: }
+
+// (Optional sanity: the class decl should be gone after conversion.)
+// CHECK-NOT: moore.class.classdecl
+
+module {
+  moore.class.classdecl @PropertyCombo {
+    moore.class.propertydecl @pubAutoI32   : !moore.i32
+    moore.class.propertydecl @protStatL18  : !moore.l18
+    moore.class.propertydecl @localAutoI32 : !moore.i32
+  }
+
+  llvm.mlir.global internal @__type_PropertyCombo()
+      : !llvm.struct<"moore.class.PropertyCombo", (i32, i18, i32)> {
+    %u = llvm.mlir.undef
+         : !llvm.struct<"moore.class.PropertyCombo", (i32, i18, i32)>
+    llvm.return %u
+         : !llvm.struct<"moore.class.PropertyCombo", (i32, i18, i32)>
+  }
+}