[ImportVerilog] Allow functions to capture values from parent scope

This patch teaches the ImportVerilog conversion to detect and plumb captured
references from enclosing scopes into lowered MLIR functions.

- **FunctionLowering**
  - Added `captures` and `captureIndex` to record refs captured from outer
    scopes.
- **Context**
  - Added `finalizeFunctionBodyCaptures` to extend the function signature with
    captured `moore::RefType` inputs and replace their in-body uses with the
    new block arguments.
  - `convertFunction` now installs a temporary `rvalueReadCallback` that
    collects refs read from outside the function’s body.
- **Expressions**
  - When lowering subroutine calls, the visitor now appends any captured
    operands to the call argument list. Captures are verified to be
    `moore::RefType` values originating from the enclosing (module) region.

Together these changes allow nested or free functions to reference module-level
signals (`logic`, etc.) correctly in the generated MLIR, with explicit
function parameters modeling captured variables.

Author: Moritz Scherer

lib/Conversion/ImportVerilog/Expressions.cpp

@@ -985,6 +985,55 @@ struct RvalueExprVisitor : public ExprVisitor {
       arguments.push_back(value);
     }
 
+    if (!lowering->captures.empty()) {
+      auto materializeCaptureAtCall = [&](Value cap) -> Value {
+        // Captures are expected to be moore::RefType.
+        auto refTy = dyn_cast<moore::RefType>(cap.getType());
+        if (!refTy) {
+          lowering->op.emitError(
+              "expected captured value to be moore::RefType");
+          return {};
+        }
+
+        // Expected case: the capture stems from a variable of any parent
+        // scope. We need to walk up, since definition might be a couple regions
+        // up.
+        Region *capRegion = [&]() -> Region * {
+          if (auto ba = dyn_cast<BlockArgument>(cap))
+            return ba.getOwner()->getParent();
+          if (auto *def = cap.getDefiningOp())
+            return def->getParentRegion();
+          return nullptr;
+        }();
+
+        Region *callRegion =
+            builder.getBlock() ? builder.getBlock()->getParent() : nullptr;
+
+        for (Region *r = callRegion; r; r = r->getParentRegion()) {
+          if (r == capRegion) {
+            // Safe to use the SSA value directly here.
+            return cap;
+          }
+        }
+
+        // Otherwise we can’t legally rematerialize this capture here.
+        lowering->op.emitError()
+            << "cannot materialize captured ref at call site; non-symbol "
+            << "source: "
+            << (cap.getDefiningOp()
+                    ? cap.getDefiningOp()->getName().getStringRef()
+                    : "<block-arg>");
+        return {};
+      };
+
+      for (Value cap : lowering->captures) {
+        Value mat = materializeCaptureAtCall(cap);
+        if (!mat)
+          return {};
+        arguments.push_back(mat);
+      }
+    }
+
     // Create the call.
     auto callOp =
         mlir::func::CallOp::create(builder, loc, lowering->op, arguments);

lib/Conversion/ImportVerilog/ImportVerilogInternals.h

@@ -49,6 +49,8 @@ struct ModuleLowering {
 /// Function lowering information.
 struct FunctionLowering {
   mlir::func::FuncOp op;
+  llvm::SmallVector<Value, 4> captures;
+  llvm::DenseMap<Value, unsigned> captureIndex;
 };
 
 /// Information about a loops continuation and exit blocks relevant while
@@ -110,6 +112,7 @@ struct Context {
   FunctionLowering *
   declareFunction(const slang::ast::SubroutineSymbol &subroutine);
   LogicalResult convertFunction(const slang::ast::SubroutineSymbol &subroutine);
+  LogicalResult finalizeFunctionBodyCaptures(FunctionLowering &lowering);
 
   // Convert a statement AST node to MLIR ops.
   LogicalResult convertStatement(const slang::ast::Statement &stmt);

lib/Conversion/ImportVerilog/Structure.cpp

@@ -1100,9 +1100,33 @@ Context::convertFunction(const slang::ast::SubroutineSymbol &subroutine) {
     valueSymbols.insert(subroutine.returnValVar, returnVar);
   }
 
+  // Save previous callback
+  auto prevCb = rvalueReadCallback;
+  auto prevCbGuard =
+      llvm::make_scope_exit([&] { rvalueReadCallback = prevCb; });
+
+  // Capture this function's captured context directly
+  rvalueReadCallback = [lowering, prevCb](moore::ReadOp rop) {
+    if (prevCb)
+      prevCb(rop); // chain previous callback
+
+    mlir::Value ref = rop.getInput();
+    // Only capture refs defined outside this function’s region
+    if (!lowering->op.getBody().isAncestor(ref.getParentRegion())) {
+      auto [it, inserted] =
+          lowering->captureIndex.try_emplace(ref, lowering->captures.size());
+      if (inserted)
+        lowering->captures.push_back(ref);
+    }
+  };
+
   if (failed(convertStatement(subroutine.getBody())))
     return failure();
 
+  // Plumb captures into the function as extra block arguments
+  if (failed(finalizeFunctionBodyCaptures(*lowering)))
+    return failure();
+
   // If there was no explicit return statement provided by the user, insert a
   // default one.
   if (builder.getBlock()) {
@@ -1130,3 +1154,49 @@ Context::convertFunction(const slang::ast::SubroutineSymbol &subroutine) {
   }
   return success();
 }
+
+LogicalResult
+Context::finalizeFunctionBodyCaptures(FunctionLowering &lowering) {
+  if (lowering.captures.empty())
+    return success();
+
+  MLIRContext *ctx = getContext();
+
+  // Build new input type list: existing inputs + capture ref types.
+  SmallVector<Type> newInputs(lowering.op.getFunctionType().getInputs().begin(),
+                              lowering.op.getFunctionType().getInputs().end());
+  for (Value cap : lowering.captures) {
+    // Expect captures to be refs.
+    Type capTy = cap.getType();
+    if (!isa<moore::RefType>(capTy)) {
+      return lowering.op.emitError(
+          "expected captured value to be a ref-like type");
+    }
+    newInputs.push_back(capTy);
+  }
+
+  // Results unchanged.
+  auto newFuncTy = FunctionType::get(
+      ctx, newInputs, lowering.op.getFunctionType().getResults());
+  lowering.op.setFunctionType(newFuncTy);
+
+  // Add the new block arguments to the entry block.
+  Block &entry = lowering.op.getBody().front();
+  SmallVector<Value> capArgs;
+  capArgs.reserve(lowering.captures.size());
+  for (Type t :
+       llvm::ArrayRef<Type>(newInputs).take_back(lowering.captures.size())) {
+    capArgs.push_back(entry.addArgument(t, lowering.op.getLoc()));
+  }
+
+  // Replace uses of each captured Value *inside the function body* with the new
+  // arg. Keep uses outside untouched (e.g., in callers).
+  for (auto [cap, idx] : lowering.captureIndex) {
+    Value arg = capArgs[idx];
+    cap.replaceUsesWithIf(arg, [&](OpOperand &use) {
+      return lowering.op->isProperAncestor(use.getOwner());
+    });
+  }
+
+  return success();
+}

test/Conversion/ImportVerilog/basic.sv

@@ -3360,3 +3360,24 @@ function automatic shortreal testShortrealLiteral();
     // CHECK-NEXT: return [[TMP]] : !moore.f32
    return test;
 endfunction
+
+// CHECK: moore.module @testFunctionCapture() {
+module testFunctionCapture();
+
+    // CHECK: [[A:%.+]] = moore.variable : <l1>
+    logic a;
+
+    function logic testCapture;
+        return a;
+    endfunction
+
+    // CHECK: [[RETURNEDA:%.+]] = func.call @testCapture([[A]]) : (!moore.ref<l1>) -> !moore.l1
+    // CHECK: [[B:%.+]] = moore.variable [[RETURNEDA]] : <l1>
+    logic b = testCapture();
+
+    // These checks need to be here since testCapture gets moved to after the variable decl,
+    // and file check only checks forward.
+    // CHECK: func.func private @testCapture(%arg0: !moore.ref<l1>) -> !moore.l1 {
+    // CHECK: [[CAPTUREDA:%.+]] = moore.read %arg0 : <l1>
+    // CHECK: return [[CAPTUREDA]] : !moore.l1
+endmodule