[ImportVerilog] Add support for string materialization and typed ret

This patch extends the ImportVerilog conversion to handle SystemVerilog string constants and improves function return handling.

- **String literal support**
  - Added `Context::materializeString` to convert Slang string constants into `moore.format_literal` ops.
  - Integrated string materialization into `Context::materializeConstant`, enabling automatic lowering of string constant values.

- **Typed return conversion**
  - Updated `StmtVisitor::visit(ReturnStatement)` to infer the enclosing function’s return type.
  - When known, the return expression is converted using the expected type, ensuring proper type consistency for function returns.

- Added `testStrLiteralReturn` to `basic.sv` verifying:
  - Emission of `moore.fmt.literal` for string literals.
  - Proper conversion and return of string-typed values.

Author: Moritz Scherer

include/circt/Dialect/Moore/MooreOps.td

@@ -571,6 +571,21 @@ def StringConstantOp : MooreOp<"string_constant", [Pure]> {
   let assemblyFormat = "$value attr-dict `:` type($result)";
 }
 
+def LiteralStringConstantOp : MooreOp<"string_literal", [Pure]> {
+  let summary = "Produce a constant string value";
+  let description = [{
+    Produces a constant value of string type.
+
+    Example:
+    ```mlir
+    %0 = moore.string_literal "hello world"
+    ```
+  }];
+  let arguments = (ins StrAttr:$value);
+  let results = (outs StringType:$result);
+  let assemblyFormat = "$value attr-dict";
+}
+
 def ShortrealLiteralOp : MooreOp<"shortreal_constant", [Pure]> {
   let summary = "Produce a constant shortreal value";
   let description = [{

lib/Conversion/ImportVerilog/Expressions.cpp

@@ -1578,6 +1578,17 @@ Value Context::materializeSVReal(const slang::ConstantValue &svreal,
   return {};
 }
 
+/// Materialize a Slang string literal as a literal string constant op.
+Value Context::materializeString(const slang::ConstantValue &stringLiteral,
+                                 const slang::ast::Type &astType,
+                                 Location loc) {
+  if (astType.isString())
+    return moore::LiteralStringConstantOp::create(builder, loc,
+                                                  stringLiteral.toString())
+        .getResult();
+  return {};
+}
+
 /// Materialize a Slang integer literal as a constant op.
 Value Context::materializeSVInt(const slang::SVInt &svint,
                                 const slang::ast::Type &astType, Location loc) {
@@ -1660,6 +1671,8 @@ Value Context::materializeConstant(const slang::ConstantValue &constant,
     return materializeSVInt(constant.integer(), type, loc);
   if (constant.isReal() || constant.isShortReal())
     return materializeSVReal(constant, type, loc);
+  if (constant.isString())
+    return materializeString(constant, type, loc);
 
   return {};
 }

lib/Conversion/ImportVerilog/ImportVerilogInternals.h

@@ -180,6 +180,10 @@ struct Context {
   Value materializeSVReal(const slang::ConstantValue &svreal,
                           const slang::ast::Type &type, Location loc);
 
+  /// Helper function to materialize a string as an SSA value.
+  Value materializeString(const slang::ConstantValue &string,
+                          const slang::ast::Type &astType, Location loc);
+
   /// Helper function to materialize an unpacked array of `SVInt`s as an SSA
   /// value.
   Value materializeFixedSizeUnpackedArrayType(

test/Conversion/ImportVerilog/basic.sv

@@ -3381,3 +3381,11 @@ module testFunctionCapture();
     // CHECK: [[CAPTUREDA:%.+]] = moore.read %arg0 : <l1>
     // CHECK: return [[CAPTUREDA]] : !moore.l1
 endmodule
+
+// CHECK: func.func private @testStrLiteralReturn() -> !moore.string {
+function string testStrLiteralReturn;
+    // CHECK-NEXT: [[STR:%.+]] = moore.string_literal "\22A string literal\22"
+    parameter string testStrLiteral = "A string literal";
+    // CHECK-NEXT: return [[STR]] : !moore.string
+    return testStrLiteral;
+endfunction // testStrLiteralReturn