[Moore] Implement ClassHandleType, ClassDeclarationOp

This change introduces first-class **class** support to the Moore dialect and teaches the Verilog importer to **recognize and lower SV classes** into that IR. It also adds an opaque **class handle type** for values of class objects.

- New **IR ops** for classes: declarations, properties, and a class-body terminator.
- New **type**: `!moore.class.object<@sym>` (with `ref` variant).
- Importer now **creates symbols for classes**, wires up `extends`/`implements`, and lowers **class-typed values** to `!moore.class.object<…>`.
- Extensive **tests** for inheritance, interfaces, properties, scoping, and handle declarations.

Author: Scheremo

include/circt/Dialect/Moore/MooreOps.td

@@ -2354,4 +2354,46 @@ def AtanhBIOp : RealMathFunc<"atanh"> {
   let summary = "Arc-hyperbolic tangent";
 }
 
+//===----------------------------------------------------------------------===//
+// Classes
+//===----------------------------------------------------------------------===//
+
+def ClassPropertyDeclOp
+    : MooreOp<"class.propertydecl", [Symbol, HasParent<"ClassDeclOp">]> {
+  let summary = "Declare a class property";
+  let description = [{
+  Declares a property within a class declaration.
+  }];
+
+  let arguments = (ins SymbolNameAttr:$sym_name, TypeAttr:$type);
+
+  let results = (outs);
+  let assemblyFormat = [{
+     $sym_name `:` $type  attr-dict
+  }];
+
+  let extraClassDeclaration = [{
+    ::mlir::Type getPropertyType() { return getTypeAttr().getValue(); }
+  }];
+}
+
+def ClassDeclOp
+    : MooreOp<"class.classdecl", [Symbol, SymbolTable, IsolatedFromAbove,
+    NoTerminator, SingleBlock]> {
+  let summary = "Class declaration";
+  let arguments = (ins SymbolNameAttr:$sym_name,
+      OptionalAttr<SymbolRefAttr>:$base,
+      OptionalAttr<SymbolRefArrayAttr>:$implementedInterfaces);
+  let results = (outs);
+  let regions = (region AnyRegion:$body);
+  let assemblyFormat = [{
+    $sym_name
+    (`extends` $base^)?
+    (`implements` $implementedInterfaces^)?
+    attr-dict-with-keyword $body
+  }];
+  let hasVerifier = 1;
+}
+
+
 #endif // CIRCT_DIALECT_MOORE_MOOREOPS

include/circt/Dialect/Moore/MooreTypes.h

@@ -43,6 +43,7 @@ class UnpackedArrayType;
 class UnpackedStructType;
 class UnpackedUnionType;
 class VoidType;
+class ClassHandleType;
 
 /// The number of values each bit of a type can assume.
 enum class Domain {
@@ -102,7 +103,8 @@ class UnpackedType : public Type {
   static bool classof(Type type) {
     return llvm::isa<PackedType, StringType, ChandleType, EventType, RealType,
                      UnpackedArrayType, OpenUnpackedArrayType, AssocArrayType,
-                     QueueType, UnpackedStructType, UnpackedUnionType>(type);
+                     QueueType, UnpackedStructType, UnpackedUnionType,
+                     ClassHandleType>(type);
   }
 
   /// Get the value domain of this type.

include/circt/Dialect/Moore/MooreTypes.td

@@ -52,6 +52,19 @@ def EventType : MooreTypeDef<"Event", [], "moore::UnpackedType"> {
   let summary = "the SystemVerilog `event` type";
 }
 
+//===----------------------------------------------------------------------===//
+// ClassHandleType
+//===----------------------------------------------------------------------===//
+
+def ClassHandleType : MooreTypeDef<"ClassHandle", [], "moore::UnpackedType"> {
+  let mnemonic = "class";
+  let summary = "Class object handle type, pointing to an object on the heap.";
+  let description = [{
+      The `!moore.class<@C>` type represents a handle of a class instance of class `@C` living on the program's heap.
+  }];
+  let parameters = (ins AttrParameter<"::mlir::SymbolRefAttr", "class symbol">:$classSym);
+  let assemblyFormat = "`<` $classSym `>`";
+}
 
 //===----------------------------------------------------------------------===//
 // TimeType
@@ -559,4 +572,6 @@ def UnionRefType : SpecificRefType<UnionType>;
 def UnpackedUnionRefType : SpecificRefType<UnpackedUnionType>;
 def AnyUnionRefType : SpecificRefType<AnyUnionType>;
 
+/// Class references.
+def ClassHandleRefType : SpecificRefType<ClassHandleType>;
 #endif // CIRCT_DIALECT_MOORE_MOORETYPES

lib/Conversion/ImportVerilog/ImportVerilogInternals.h

@@ -55,6 +55,11 @@ struct FunctionLowering {
   bool isConverting = false;
 };
 
+// Class lowering information.
+struct ClassLowering {
+  circt::moore::ClassDeclOp op;
+};
+
 /// Information about a loops continuation and exit blocks relevant while
 /// lowering the loop's body statements.
 struct LoopFrame {
@@ -115,6 +120,8 @@ struct Context {
   declareFunction(const slang::ast::SubroutineSymbol &subroutine);
   LogicalResult convertFunction(const slang::ast::SubroutineSymbol &subroutine);
   LogicalResult finalizeFunctionBodyCaptures(FunctionLowering &lowering);
+  LogicalResult convertClassDeclaration(const slang::ast::ClassType &classdecl);
+  ClassLowering *declareClass(const slang::ast::ClassType &cls);
 
   // Convert a statement AST node to MLIR ops.
   LogicalResult convertStatement(const slang::ast::Statement &stmt);
@@ -252,6 +259,10 @@ struct Context {
            std::unique_ptr<FunctionLowering>>
       functions;
 
+  /// Classes that have already been converted.
+  DenseMap<const slang::ast::ClassType *, std::unique_ptr<ClassLowering>>
+      classes;
+
   /// A table of defined values, such as variables, that may be referred to by
   /// name in expressions. The expressions use this table to lookup the MLIR
   /// value that was created for a given declaration in the Slang AST node.
@@ -298,5 +309,4 @@ struct Context {
 
 } // namespace ImportVerilog
 } // namespace circt
-
 #endif // CONVERSION_IMPORTVERILOG_IMPORTVERILOGINTERNALS_H

lib/Conversion/ImportVerilog/Structure.cpp

@@ -8,6 +8,7 @@
 
 #include "ImportVerilogInternals.h"
 #include "slang/ast/Compilation.h"
+#include "slang/ast/symbols/ClassSymbols.h"
 #include "llvm/ADT/ScopeExit.h"
 
 using namespace circt;
@@ -54,6 +55,11 @@ struct BaseVisitor {
     return success();
   }
 
+  // Handle classes without parameters
+  LogicalResult visit(const slang::ast::ClassType &classdecl) {
+    return context.convertClassDeclaration(classdecl);
+  }
+
   // Skip typedefs.
   LogicalResult visit(const slang::ast::TypeAliasType &) { return success(); }
   LogicalResult visit(const slang::ast::ForwardingTypedefSymbol &) {
@@ -1309,3 +1315,204 @@ Context::finalizeFunctionBodyCaptures(FunctionLowering &lowering) {
 
   return success();
 }
+
+namespace {
+
+/// Construct a fully qualified class name containing the instance hierarchy
+/// and the class name formatted as H1::H2::@C
+mlir::StringAttr fullyQualifiedClassName(Context &ctx,
+                                         const slang::ast::Type &ty) {
+  SmallString<64> name;
+  SmallVector<llvm::StringRef, 8> parts;
+
+  const slang::ast::Scope *scope = ty.getParentScope();
+  while (scope) {
+    const auto &sym = scope->asSymbol();
+    switch (sym.kind) {
+    case slang::ast::SymbolKind::Root:
+      scope = nullptr; // stop at $root
+      continue;
+    case slang::ast::SymbolKind::InstanceBody:
+    case slang::ast::SymbolKind::Instance:
+    case slang::ast::SymbolKind::Package:
+    case slang::ast::SymbolKind::ClassType:
+      if (!sym.name.empty())
+        parts.push_back(sym.name); // keep packages + outer classes
+      break;
+    default:
+      break;
+    }
+    scope = sym.getParentScope();
+  }
+
+  for (auto p : llvm::reverse(parts)) {
+    name += p;
+    name += "::";
+  }
+  name += ty.name; // class’s own name
+  return mlir::StringAttr::get(ctx.getContext(), name);
+}
+
+/// Helper function to construct the classes fully qualified base class name
+/// and the name of all implemented interface classes
+std::pair<mlir::SymbolRefAttr, mlir::ArrayAttr>
+buildBaseAndImplementsAttrs(Context &context,
+                            const slang::ast::ClassType &cls) {
+  mlir::MLIRContext *ctx = context.getContext();
+
+  // Base class (if any)
+  mlir::SymbolRefAttr base;
+  if (const auto *b = cls.getBaseClass())
+    base = mlir::SymbolRefAttr::get(fullyQualifiedClassName(context, *b));
+
+  // Implemented interfaces (if any)
+  SmallVector<mlir::Attribute> impls;
+  if (auto ifaces = cls.getDeclaredInterfaces(); !ifaces.empty()) {
+    impls.reserve(ifaces.size());
+    for (const auto *iface : ifaces)
+      impls.push_back(mlir::FlatSymbolRefAttr::get(
+          fullyQualifiedClassName(context, *iface)));
+  }
+
+  mlir::ArrayAttr implArr =
+      impls.empty() ? mlir::ArrayAttr() : mlir::ArrayAttr::get(ctx, impls);
+
+  return {base, implArr};
+}
+
+/// Visit a slang::ast::ClassType and populate the body of an existing
+/// moore::ClassDeclOp with field/method decls.
+struct ClassDeclVisitor {
+  Context &context;
+  OpBuilder &builder;
+  ClassLowering &classLowering;
+
+  ClassDeclVisitor(Context &ctx, ClassLowering &lowering)
+      : context(ctx), builder(ctx.builder), classLowering(lowering) {}
+
+  LogicalResult run(const slang::ast::ClassType &classAST) {
+    OpBuilder::InsertionGuard ig(builder);
+    Block *body = classLowering.op.getBody().empty()
+                      ? &classLowering.op.getBody().emplaceBlock()
+                      : &classLowering.op.getBody().front();
+    builder.setInsertionPointToEnd(body);
+
+    for (const auto &mem : classAST.members())
+      if (failed(mem.visit(*this)))
+        return failure();
+
+    return success();
+  }
+
+  // Properties: ClassPropertySymbol
+  LogicalResult visit(const slang::ast::ClassPropertySymbol &prop) {
+    auto loc = convertLocation(prop.location);
+    auto ty = context.convertType(prop.getType());
+    if (!ty)
+      return failure();
+
+    moore::ClassPropertyDeclOp::create(builder, loc, prop.name, ty);
+    return success();
+  }
+
+  // Fully-fledged functions - SubroutineSymbol
+  LogicalResult visit(const slang::ast::SubroutineSymbol &fn) {
+    if (fn.flags & slang::ast::MethodFlags::BuiltIn) {
+      static bool remarkEmitted = false;
+      if (remarkEmitted)
+        return success();
+
+      mlir::emitRemark(classLowering.op.getLoc())
+          << "Class builtin functions (needed for randomization, constraints, "
+             "and covergroups) are not yet supported and will be dropped "
+             "during lowering.";
+      remarkEmitted = true;
+      return success();
+    }
+    return failure();
+  }
+
+  // Nested class definition, convert
+  LogicalResult visit(const slang::ast::ClassType &cls) {
+    return context.convertClassDeclaration(cls);
+  }
+
+  // Transparent members: ignore (inherited names pulled in by slang)
+  LogicalResult visit(const slang::ast::TransparentMemberSymbol &) {
+    return success();
+  }
+
+  // Empty members: ignore
+  LogicalResult visit(const slang::ast::EmptyMemberSymbol &) {
+    return success();
+  }
+
+  // Emit an error for all other members.
+  template <typename T>
+  LogicalResult visit(T &&node) {
+    Location loc = UnknownLoc::get(context.getContext());
+    if constexpr (requires { node.location; })
+      loc = convertLocation(node.location);
+    mlir::emitError(loc) << "unsupported construct in ClassType members: "
+                         << slang::ast::toString(node.kind);
+    return failure();
+  }
+
+private:
+  Location convertLocation(const slang::SourceLocation &sloc) {
+    return context.convertLocation(sloc);
+  }
+};
+} // namespace
+
+ClassLowering *Context::declareClass(const slang::ast::ClassType &cls) {
+  // Check if there already is a declaration for this class.
+  auto &lowering = classes[&cls];
+  if (lowering) {
+    if (!lowering->op)
+      return {};
+    return lowering.get();
+  }
+
+  lowering = std::make_unique<ClassLowering>();
+  auto loc = convertLocation(cls.location);
+
+  // Pick an insertion point for this function according to the source file
+  // location.
+  OpBuilder::InsertionGuard g(builder);
+  auto it = orderedRootOps.upper_bound(cls.location);
+  if (it == orderedRootOps.end())
+    builder.setInsertionPointToEnd(intoModuleOp.getBody());
+  else
+    builder.setInsertionPoint(it->second);
+
+  auto symName = fullyQualifiedClassName(*this, cls);
+  auto [base, impls] = buildBaseAndImplementsAttrs(*this, cls);
+
+  auto classDeclOp =
+      moore::ClassDeclOp::create(builder, loc, symName, base, impls);
+
+  SymbolTable::setSymbolVisibility(classDeclOp,
+                                   SymbolTable::Visibility::Public);
+  orderedRootOps.insert(it, {cls.location, classDeclOp});
+  lowering->op = classDeclOp;
+
+  symbolTable.insert(classDeclOp);
+  return lowering.get();
+}
+
+LogicalResult
+Context::convertClassDeclaration(const slang::ast::ClassType &classdecl) {
+
+  // Keep track of local time scale.
+  auto prevTimeScale = timeScale;
+  timeScale = classdecl.getTimeScale().value_or(slang::TimeScale());
+  auto timeScaleGuard =
+      llvm::make_scope_exit([&] { timeScale = prevTimeScale; });
+
+  auto *lowering = declareClass(classdecl);
+  if (failed(ClassDeclVisitor(*this, *lowering).run(classdecl)))
+    return failure();
+
+  return success();
+}

lib/Conversion/ImportVerilog/Types.cpp

@@ -166,6 +166,15 @@ struct TypeVisitor {
     return moore::ChandleType::get(context.getContext());
   }
 
+  Type visit(const slang::ast::ClassType &type) {
+    if (auto *lowering = context.declareClass(type)) {
+      mlir::StringAttr symName = lowering->op.getSymNameAttr();
+      mlir::FlatSymbolRefAttr symRef = mlir::FlatSymbolRefAttr::get(symName);
+      return moore::ClassHandleType::get(context.getContext(), symRef);
+    }
+    return {};
+  }
+
   /// Emit an error for all other types.
   template <typename T>
   Type visit(T &&node) {

lib/Dialect/Moore/MooreOps.cpp

@@ -1366,6 +1366,28 @@ OpFoldResult DivSOp::fold(FoldAdaptor adaptor) {
   return {};
 }
 
+//===----------------------------------------------------------------------===//
+// Classes
+//===----------------------------------------------------------------------===//
+
+LogicalResult ClassDeclOp::verify() {
+  mlir::Region &body = getBody();
+  if (body.empty())
+    return mlir::success();
+
+  auto &block = body.front();
+  for (mlir::Operation &op : block) {
+
+    // allow only property and method decls and terminator
+    if (llvm::isa<circt::moore::ClassPropertyDeclOp>(&op))
+      continue;
+
+    return emitOpError()
+           << "body may only contain 'moore.class.propertydecl' operations";
+  }
+  return mlir::success();
+}
+
 //===----------------------------------------------------------------------===//
 // TableGen generated logic.
 //===----------------------------------------------------------------------===//