[OM] Add evaluator support for StringConcatOp

Implement string concatenation evaluation in the OM evaluator. The
evaluator extracts string attributes from both operands and concatenates
them to produce a new string attribute.

This enables runtime evaluation of string concatenation operations in
the OM dialect.

Signed-off-by: Schuyler Eldridge <schuyler.eldridge@sifive.com>

Author: seldridge

include/circt/Dialect/OM/Evaluator/Evaluator.h

@@ -440,6 +440,9 @@ class Evaluator {
   FailureOr<EvaluatorValuePtr> evaluateListConcat(ListConcatOp op,
                                                   ActualParameters actualParams,
                                                   Location loc);
+  FailureOr<EvaluatorValuePtr>
+  evaluateStringConcat(StringConcatOp op, ActualParameters actualParams,
+                       Location loc);
   FailureOr<evaluator::EvaluatorValuePtr>
   evaluateBasePathCreate(FrozenBasePathCreateOp op,
                          ActualParameters actualParams, Location loc);

lib/Dialect/OM/Evaluator/Evaluator.cpp

@@ -90,6 +90,11 @@ circt::om::Evaluator::getPartiallyEvaluatedValue(Type type, Location loc) {
 
         return success(result);
       })
+      .Case([&](circt::om::StringType type) {
+        evaluator::EvaluatorValuePtr result =
+            evaluator::AttributeValue::get(type, loc);
+        return success(result);
+      })
       .Default([&](auto type) { return failure(); });
 }
 
@@ -155,7 +160,8 @@ FailureOr<evaluator::EvaluatorValuePtr> circt::om::Evaluator::getOrCreateValue(
                           evaluator::PathValue::getEmptyPath(loc));
                   return success(result);
                 })
-                .Case<ListCreateOp, ListConcatOp, ObjectFieldOp>([&](auto op) {
+                .Case<ListCreateOp, ListConcatOp, StringConcatOp,
+                      ObjectFieldOp>([&](auto op) {
                   return getPartiallyEvaluatedValue(op.getType(), loc);
                 })
                 .Case<ObjectOp>([&](auto op) {
@@ -378,6 +384,9 @@ circt::om::Evaluator::evaluateValue(Value value, ActualParameters actualParams,
             .Case([&](ListConcatOp op) {
               return evaluateListConcat(op, actualParams, loc);
             })
+            .Case([&](StringConcatOp op) {
+              return evaluateStringConcat(op, actualParams, loc);
+            })
             .Case([&](AnyCastOp op) {
               return evaluateValue(op.getInput(), actualParams, loc);
             })
@@ -680,6 +689,63 @@ circt::om::Evaluator::evaluateListConcat(ListConcatOp op,
   return list;
 }
 
+/// Evaluator dispatch function for String concatenation.
+FailureOr<evaluator::EvaluatorValuePtr>
+circt::om::Evaluator::evaluateStringConcat(StringConcatOp op,
+                                           ActualParameters actualParams,
+                                           Location loc) {
+  // Get the op's EvaluatorValue handle, in case it hasn't been evaluated yet.
+  auto handle = getOrCreateValue(op.getResult(), actualParams, loc);
+  if (failed(handle))
+    return handle;
+
+  // If it's fully evaluated, we can return it.
+  if (handle.value()->isFullyEvaluated())
+    return handle;
+
+  // Extract the string attributes, handling both AttributeValue and
+  // ReferenceValue cases.
+  auto extractAttr = [](evaluator::EvaluatorValue *value) -> StringAttr {
+    return llvm::TypeSwitch<evaluator::EvaluatorValue *, StringAttr>(value)
+        .Case([](evaluator::AttributeValue *val) {
+          return val->getAs<StringAttr>();
+        })
+        .Case([](evaluator::ReferenceValue *val) {
+          return cast<evaluator::AttributeValue>(val->getStrippedValue()->get())
+              ->getAs<StringAttr>();
+        });
+  };
+
+  // Evaluate all operands and concatenate them.
+  std::string result;
+  for (auto operand : op.getOperands()) {
+    auto operandResult = evaluateValue(operand, actualParams, loc);
+    if (failed(operandResult))
+      return operandResult;
+    if (!operandResult.value()->isFullyEvaluated())
+      return handle;
+
+    StringAttr str = extractAttr(operandResult.value().get());
+    assert(str && "expected StringAttr for StringConcatOp operand");
+    result += str.getValue().str();
+  }
+
+  // Create the concatenated string attribute.
+  auto resultStr = StringAttr::get(result, op.getResult().getType());
+
+  // Finalize the op result value.
+  auto *handleValue = cast<evaluator::AttributeValue>(handle.value().get());
+  auto resultStatus = handleValue->setAttr(resultStr);
+  if (failed(resultStatus))
+    return resultStatus;
+
+  auto finalizeStatus = handleValue->finalize();
+  if (failed(finalizeStatus))
+    return finalizeStatus;
+
+  return handle;
+}
+
 FailureOr<evaluator::EvaluatorValuePtr>
 circt::om::Evaluator::evaluateBasePathCreate(FrozenBasePathCreateOp op,
                                              ActualParameters actualParams,

unittests/Dialect/OM/Evaluator/EvaluatorTests.cpp

@@ -1661,4 +1661,45 @@ om.class @Foo(
   ASSERT_TRUE(object->getField("b").value()->isUnknown());
 }
 
+TEST(EvaluatorTests, StringConcat) {
+  const char *mod = R"MLIR(
+module {
+  om.class @Test() -> (result: !om.string) {
+    %0 = om.constant "Hello, " : !om.string
+    %1 = om.constant "World!" : !om.string
+    %2 = om.string.concat %0, %1 : !om.string
+    om.class.fields %2 : !om.string
+  }
+}
+)MLIR";
+
+  DialectRegistry registry;
+  registry.insert<OMDialect>();
+
+  MLIRContext context(registry);
+  context.getOrLoadDialect<OMDialect>();
+
+  OwningOpRef<ModuleOp> owning =
+      parseSourceString<ModuleOp>(mod, ParserConfig(&context));
+
+  Evaluator evaluator(owning.release());
+
+  context.getDiagEngine().registerHandler([&](Diagnostic &diag) {
+    llvm::errs() << "Diagnostic: " << diag << "\n";
+  });
+
+  auto result = evaluator.instantiate(StringAttr::get(&context, "Test"), {});
+
+  ASSERT_TRUE(succeeded(result));
+
+  auto fieldValue = llvm::cast<evaluator::ObjectValue>(result.value().get())
+                        ->getField("result")
+                        .value();
+
+  ASSERT_EQ("Hello, World!",
+            llvm::cast<evaluator::AttributeValue>(fieldValue.get())
+                ->getAs<StringAttr>()
+                .getValue());
+}
+
 } // namespace