Expressions.cpp

Go to the documentation of this file.

//===- Expressions.cpp - Slang expression conversion ----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "ImportVerilogInternals.h"
#include "circt/Dialect/Comb/CombOps.h"
#include "circt/Dialect/Moore/MooreOps.h"
#include "circt/Dialect/Moore/MooreTypes.h"
#include "circt/Support/FVInt.h"
#include "mlir/IR/Operation.h"
#include "mlir/IR/Value.h"
#include "slang/ast/EvalContext.h"
#include "slang/ast/SystemSubroutine.h"
#include "slang/ast/types/AllTypes.h"
#include "slang/syntax/AllSyntax.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/SaveAndRestore.h"
 
using namespace circt;
using namespace ImportVerilog;
using moore::Domain;
 
/// Convert a Slang `SVInt` to a CIRCT `FVInt`.
static FVInt convertSVIntToFVInt(const slang::SVInt &svint) {
  if (svint.hasUnknown()) {
    unsigned numWords = svint.getNumWords() / 2;
    auto value = ArrayRef<uint64_t>(svint.getRawPtr(), numWords);
    auto unknown = ArrayRef<uint64_t>(svint.getRawPtr() + numWords, numWords);
    return FVInt(APInt(svint.getBitWidth(), value),
                 APInt(svint.getBitWidth(), unknown));
  }
  auto value = ArrayRef<uint64_t>(svint.getRawPtr(), svint.getNumWords());
  return FVInt(APInt(svint.getBitWidth(), value));
}
 
/// Check if a Moore integer value contains any unknown (x/z) bits.
/// Returns a Moore i1 result: 1 if any bit is unknown, 0 otherwise.
static Value getIsUnknown(OpBuilder &builder, Location loc, Value value,
                          moore::IntType valTy, MLIRContext *ctx) {
  Value bitVal = value;
  if (valTy.getWidth() > 1) {
    auto mooreI1Type = moore::IntType::get(ctx, 1, valTy.getDomain());
    bitVal = moore::ReduceXorOp::create(builder, loc, mooreI1Type, value);
  }
  auto xType = moore::IntType::get(ctx, 1, moore::Domain::FourValued);
  auto xConst =
      moore::ConstantOp::create(builder, loc, xType, FVInt::getAllX(1));
  return moore::CaseEqOp::create(builder, loc, bitVal, xConst).getResult();
}
 
/// Coerce a Moore integer value to a builtin integer, handling four-valued
/// inputs by first mapping x/z to 0 via LogicToIntOp.
static Value coerceToBuiltinInt(OpBuilder &builder, Location loc, Value value,
                                moore::IntType valTy) {
  if (valTy.getDomain() == moore::Domain::FourValued)
    value = builder.createOrFold<moore::LogicToIntOp>(loc, value);
  return builder.createOrFold<moore::ToBuiltinIntOp>(loc, value);
}
 
Value ImportVerilog::getSelectIndex(Context &context, Location loc, Value index,
                                    const slang::ConstantRange &range) {
  auto &builder = context.builder;
  auto indexType = cast<moore::UnpackedType>(index.getType());
 
  // Compute offset first so we know if it is negative.
  auto lo = range.lower();
  auto hi = range.upper();
  auto offset = range.isDescending() ? lo : hi;
 
  // If any bound is negative we need a signed index type.
  const bool needSigned = (lo < 0) || (hi < 0);
 
  // Magnitude over full range, not just the chosen offset.
  const uint64_t maxAbs = std::max<uint64_t>(std::abs(lo), std::abs(hi));
 
  // Bits needed from the range:
  //  - unsigned: ceil(log2(maxAbs + 1)) (ensure at least 1)
  //  - signed:   ceil(log2(maxAbs)) + 1 sign bit (ensure at least 2 when neg)
  unsigned want = needSigned
                      ? (llvm::Log2_64_Ceil(std::max<uint64_t>(1, maxAbs)) + 1)
                      : std::max<unsigned>(1, llvm::Log2_64_Ceil(maxAbs + 1));
 
  // Keep at least as wide as the incoming index.
  const unsigned bw = std::max<unsigned>(want, indexType.getBitSize().value());
 
  auto intType =
      moore::IntType::get(index.getContext(), bw, indexType.getDomain());
  index = context.materializeConversion(intType, index, needSigned, loc);
 
  if (offset == 0) {
    if (range.isDescending())
      return index;
    return moore::NegOp::create(builder, loc, index);
  }
 
  auto offsetConst =
      moore::ConstantOp::create(builder, loc, intType, offset, needSigned);
  if (range.isDescending())
    return moore::SubOp::create(builder, loc, index, offsetConst);
  return moore::SubOp::create(builder, loc, offsetConst, index);
}
 
/// Get the currently active timescale as an integer number of femtoseconds.
static uint64_t getTimeScaleInFemtoseconds(Context &context) {
  static_assert(int(slang::TimeUnit::Seconds) == 0);
  static_assert(int(slang::TimeUnit::Milliseconds) == 1);
  static_assert(int(slang::TimeUnit::Microseconds) == 2);
  static_assert(int(slang::TimeUnit::Nanoseconds) == 3);
  static_assert(int(slang::TimeUnit::Picoseconds) == 4);
  static_assert(int(slang::TimeUnit::Femtoseconds) == 5);
 
  static_assert(int(slang::TimeScaleMagnitude::One) == 1);
  static_assert(int(slang::TimeScaleMagnitude::Ten) == 10);
  static_assert(int(slang::TimeScaleMagnitude::Hundred) == 100);
 
  auto exp = static_cast<unsigned>(context.timeScale.base.unit);
  assert(exp <= 5);
  exp = 5 - exp;
  auto scale = static_cast<uint64_t>(context.timeScale.base.magnitude);
  while (exp-- > 0)
    scale *= 1000;
  return scale;
}
 
/// Resolve a hierarchical value that refers to a member of an expanded
/// interface instance.
static Value lookupExpandedInterfaceMember(
    Context &context, const slang::ast::HierarchicalValueExpression &expr) {
  auto nameAttr = context.builder.getStringAttr(expr.symbol.name);
  for (const auto &element : expr.ref.path) {
    auto *inst = element.symbol->as_if<slang::ast::InstanceSymbol>();
    if (!inst)
      continue;
    auto *lowering = context.interfaceInstances.lookup(inst);
    if (!lowering)
      continue;
    if (auto it = lowering->expandedMembers.find(&expr.symbol);
        it != lowering->expandedMembers.end())
      return it->second;
    if (auto it = lowering->expandedMembersByName.find(nameAttr);
        it != lowering->expandedMembersByName.end())
      return it->second;
  }
  return {};
}
 
static Value visitClassProperty(Context &context,
                                const slang::ast::ClassPropertySymbol &expr) {
  auto loc = context.convertLocation(expr.location);
  auto builder = context.builder;
  auto type = context.convertType(expr.getType());
  auto fieldTy = cast<moore::UnpackedType>(type);
  auto fieldRefTy = moore::RefType::get(fieldTy);
 
  if (expr.lifetime == slang::ast::VariableLifetime::Static) {
 
    // Variable may or may not have been hoisted already. Hoist if not.
    if (!context.globalVariables.lookup(&expr)) {
      if (failed(context.convertGlobalVariable(expr))) {
        return {};
      }
    }
    // Try the static variable after it has been hoisted.
    if (auto globalOp = context.globalVariables.lookup(&expr))
      return moore::GetGlobalVariableOp::create(builder, loc, globalOp);
 
    mlir::emitError(loc) << "Failed to access static member variable "
                         << expr.name << " as a global variable";
    return {};
  }
 
  // Get the scope's implicit this variable
  mlir::Value instRef = context.getImplicitThisRef();
  if (!instRef) {
    mlir::emitError(loc) << "class property '" << expr.name
                         << "' referenced without an implicit 'this'";
    return {};
  }
 
  auto fieldSym = mlir::FlatSymbolRefAttr::get(builder.getContext(), expr.name);
 
  moore::ClassHandleType classTy =
      cast<moore::ClassHandleType>(instRef.getType());
 
  auto targetClassHandle =
      context.getAncestorClassWithProperty(classTy, expr.name, loc);
  if (!targetClassHandle)
    return {};
 
  auto upcastRef = context.materializeConversion(targetClassHandle, instRef,
                                                 false, instRef.getLoc());
  if (!upcastRef)
    return {};
 
  Value fieldRef = moore::ClassPropertyRefOp::create(builder, loc, fieldRefTy,
                                                     upcastRef, fieldSym);
  return fieldRef;
}
 
/// Ensures that the given range is in "descending" order.
///
/// `type` must have a fixed range. If the range is defined such that
/// left < right, the range is reversed.
///
/// For example:
///   [3:0] => do not reverse
///   [0:3] => reverse
///
/// The resulting range is suitable for passing to ops like ConcatOp and
/// packed ArrayCreateOp which expect operands to be in descending order
/// of bit significance. Do not call on unpacked arrays, whose element
/// indexing logic (getSelectIndex / translateIndex) already maps ascending
/// indices to descending storage order.
template <typename RangeT>
static void ensureDescendingOrder(RangeT &range, const slang::ast::Type &type) {
  assert(type.hasFixedRange());
  const slang::ConstantRange &cstRange = type.getFixedRange();
  if (cstRange.left < cstRange.right)
    std::reverse(std::begin(range), std::end(range));
}
 
namespace {
/// A visitor handling expressions that can be lowered as lvalue and rvalue.
struct ExprVisitor {
  Context &context;
  Location loc;
  OpBuilder &builder;
  bool isLvalue;
 
  ExprVisitor(Context &context, Location loc, bool isLvalue)
      : context(context), loc(loc), builder(context.builder),
        isLvalue(isLvalue) {}
 
  /// Convert an expression either as an lvalue or rvalue, depending on whether
  /// this is an lvalue or rvalue visitor. This is useful for projections such
  /// as `a[i]`, where you want `a` as an lvalue if you want `a[i]` as an
  /// lvalue, or `a` as an rvalue if you want `a[i]` as an rvalue.
  Value convertLvalueOrRvalueExpression(const slang::ast::Expression &expr) {
    if (isLvalue)
      return context.convertLvalueExpression(expr);
    return context.convertRvalueExpression(expr);
  }
 
  /// Materialize the rvalue of a symbol, regardless of whether it is backed by
  /// a local reference, global variable, or class property.
  Value materializeSymbolRvalue(const slang::ast::ValueSymbol &sym) {
    if (auto value = context.valueSymbols.lookup(&sym)) {
      if (isa<moore::RefType>(value.getType())) {
        auto readOp = moore::ReadOp::create(builder, loc, value);
        if (context.rvalueReadCallback)
          context.rvalueReadCallback(readOp);
        return readOp.getResult();
      }
      return value;
    }
 
    if (auto globalOp = context.globalVariables.lookup(&sym)) {
      auto ref = moore::GetGlobalVariableOp::create(builder, loc, globalOp);
      auto readOp = moore::ReadOp::create(builder, loc, ref);
      if (context.rvalueReadCallback)
        context.rvalueReadCallback(readOp);
      return readOp.getResult();
    }
 
    if (auto *const property = sym.as_if<slang::ast::ClassPropertySymbol>()) {
      auto fieldRef = visitClassProperty(context, *property);
      auto readOp = moore::ReadOp::create(builder, loc, fieldRef);
      if (context.rvalueReadCallback)
        context.rvalueReadCallback(readOp);
      return readOp.getResult();
    }
 
    return {};
  }
 
  Value visit(const slang::ast::NewArrayExpression &expr) {
    Type type = context.convertType(*expr.type);
 
    // TODO: Handle 'initExpr' if it exists
 
    if (expr.initExpr()) {
      mlir::emitError(loc)
          << "unsupported expression: array `new` with initializer\n";
      return {};
    }
 
    auto initialSize = context.convertRvalueExpression(
        expr.sizeExpr(), context.convertType(*expr.sizeExpr().type));
    if (!initialSize)
      return {};
 
    return moore::OpenUArrayCreateOp::create(builder, loc, type, initialSize);
  }
 
  /// Handle single bit selections.
  Value visit(const slang::ast::ElementSelectExpression &expr) {
    auto type = context.convertType(*expr.type);
    auto value = convertLvalueOrRvalueExpression(expr.value());
    if (!type || !value)
      return {};
 
    // We only support indexing into a few select types for now.
    auto derefType = value.getType();
    if (isLvalue)
      derefType = cast<moore::RefType>(derefType).getNestedType();
 
    if (!isa<moore::IntType, moore::ArrayType, moore::UnpackedArrayType,
             moore::QueueType, moore::AssocArrayType, moore::StringType,
             moore::OpenUnpackedArrayType, moore::StructType, moore::UnionType>(
            derefType)) {
      mlir::emitError(loc) << "unsupported expression: element select into "
                           << expr.value().type->toString() << "\n";
      return {};
    }
 
    if (!isLvalue && isa<moore::StructType, moore::UnionType>(derefType)) {
      value = context.convertToSimpleBitVector(value);
      if (!value)
        return {};
      derefType = value.getType();
    }
 
    // Associative Arrays are a special case so handle them separately.
    if (isa<moore::AssocArrayType>(derefType)) {
      auto assocArray = cast<moore::AssocArrayType>(derefType);
      auto expectedIndexType = assocArray.getIndexType();
      auto givenIndex = context.convertRvalueExpression(expr.selector());
 
      if (!givenIndex)
        return {};
 
      if (givenIndex.getType() != expectedIndexType) {
        mlir::emitError(loc)
            << "Incorrect index type: expected index type of "
            << expectedIndexType << " but was given " << givenIndex.getType();
      }
 
      if (isLvalue)
        return moore::AssocArrayExtractRefOp::create(
            builder, loc, moore::RefType::get(cast<moore::UnpackedType>(type)),
            value, givenIndex);
 
      return moore::AssocArrayExtractOp::create(builder, loc, type, value,
                                                givenIndex);
    }
 
    // Handle string indexing.
    if (isa<moore::StringType>(derefType)) {
      if (isLvalue) {
        mlir::emitError(loc) << "string index assignment not supported";
        return {};
      }
 
      // Convert the index to an rvalue with the required type (TwoValuedI32).
      auto i32Type = moore::IntType::getInt(builder.getContext(), 32);
      auto index = context.convertRvalueExpression(expr.selector(), i32Type);
      if (!index)
        return {};
 
      // Create the StringGetOp operation.
      return moore::StringGetOp::create(builder, loc, value, index);
    }
 
    auto resultType =
        isLvalue ? moore::RefType::get(cast<moore::UnpackedType>(type)) : type;
    auto range = expr.value().type->getFixedRange();
    if (auto *constValue = expr.selector().getConstant();
        constValue && constValue->isInteger()) {
      assert(!constValue->hasUnknown());
      assert(constValue->size() <= 32);
 
      auto lowBit = constValue->integer().as<uint32_t>().value();
      if (isLvalue)
        return llvm::TypeSwitch<Type, Value>(derefType)
            .Case<moore::QueueType>([&](moore::QueueType) {
              mlir::emitError(loc)
                  << "Unexpected LValue extract on Queue Type!";
              return Value();
            })
            .Default([&](Type) {
              return moore::ExtractRefOp::create(builder, loc, resultType,
                                                 value,
                                                 range.translateIndex(lowBit));
            });
      return llvm::TypeSwitch<Type, Value>(derefType)
          .Case<moore::QueueType>([&](moore::QueueType) {
            mlir::emitError(loc) << "Unexpected RValue extract on Queue Type!";
            return Value();
          })
          .Default([&](Type) {
            return moore::ExtractOp::create(builder, loc, resultType, value,
                                            range.translateIndex(lowBit));
          });
    }
 
    // Save the queue which is being indexed: this allows us to handle the `$`
    // operator, which evaluates to the last valid index in the queue.
    Value savedQueue = context.currentQueue;
    llvm::scope_exit restoreQueue([&] { context.currentQueue = savedQueue; });
    if (isa<moore::QueueType>(derefType)) {
      // For QueueSizeBIOp, we need a byvalue queue, so if the queue is an
      // lvalue (because we're assigning to it), we need to dereference it
      if (isa<moore::RefType>(value.getType())) {
        context.currentQueue = moore::ReadOp::create(builder, loc, value);
      } else {
        context.currentQueue = value;
      }
    }
    auto lowBit = context.convertRvalueExpression(expr.selector());
 
    if (!lowBit)
      return {};
    lowBit = getSelectIndex(context, loc, lowBit, range);
    if (isLvalue)
      return llvm::TypeSwitch<Type, Value>(derefType)
          .Case<moore::QueueType>([&](moore::QueueType) {
            return moore::DynQueueRefElementOp::create(builder, loc, resultType,
                                                       value, lowBit);
          })
          .Default([&](Type) {
            return moore::DynExtractRefOp::create(builder, loc, resultType,
                                                  value, lowBit);
          });
 
    return llvm::TypeSwitch<Type, Value>(derefType)
        .Case<moore::QueueType>([&](moore::QueueType) {
          return moore::DynQueueExtractOp::create(builder, loc, resultType,
                                                  value, lowBit, lowBit);
        })
        .Default([&](Type) {
          return moore::DynExtractOp::create(builder, loc, resultType, value,
                                             lowBit);
        });
  }
 
  /// Handle null assignments to variables.
  /// Compare with IEEE 1800-2023 Table 6-7 - Default variable initial values
  Value visit(const slang::ast::NullLiteral &expr) {
    auto type = context.convertType(*expr.type);
    if (isa<moore::ClassHandleType, moore::ChandleType, moore::EventType,
            moore::NullType>(type))
      return moore::NullOp::create(builder, loc);
    mlir::emitError(loc) << "No null value definition found for value of type "
                         << type;
    return {};
  }
 
  /// Handle range bit selections.
  Value visit(const slang::ast::RangeSelectExpression &expr) {
    auto type = context.convertType(*expr.type);
    auto value = convertLvalueOrRvalueExpression(expr.value());
    if (!type || !value)
      return {};
 
    auto derefType = value.getType();
    if (isLvalue)
      derefType = cast<moore::RefType>(derefType).getNestedType();
 
    if (isa<moore::QueueType>(derefType)) {
      return handleQueueRangeSelectExpressions(expr, type, value);
    }
    if (!isLvalue && isa<moore::StructType, moore::UnionType>(derefType)) {
      value = context.convertToSimpleBitVector(value);
      if (!value)
        return {};
    }
 
    return handleArrayRangeSelectExpressions(expr, type, value);
  }
 
  // Handles range selections into queues, in which neither bound needs to be
  // constant
  Value handleQueueRangeSelectExpressions(
      const slang::ast::RangeSelectExpression &expr, Type type, Value value) {
    Value savedQueue = context.currentQueue;
    llvm::scope_exit restoreQueue([&] { context.currentQueue = savedQueue; });
    context.currentQueue = value;
 
    auto lowerIdx = context.convertRvalueExpression(expr.left());
    auto upperIdx = context.convertRvalueExpression(expr.right());
    auto resultType =
        isLvalue ? moore::RefType::get(cast<moore::UnpackedType>(type)) : type;
 
    if (isLvalue) {
      mlir::emitError(loc) << "queue lvalue range selections are not supported";
      return {};
    }
    return moore::DynQueueExtractOp::create(builder, loc, resultType, value,
                                            lowerIdx, upperIdx);
  }
 
  // Handles range selections into arrays, which currently require a constant
  // upper bound
  Value handleArrayRangeSelectExpressions(
      const slang::ast::RangeSelectExpression &expr, Type type, Value value) {
    std::optional<int32_t> constLeft;
    std::optional<int32_t> constRight;
    if (auto *constant = expr.left().getConstant())
      constLeft = constant->integer().as<int32_t>();
    if (auto *constant = expr.right().getConstant())
      constRight = constant->integer().as<int32_t>();
 
    // We currently require the right-hand-side of the range to be constant.
    // This catches things like `[42:$]` which we don't support at the moment.
    if (!constRight) {
      mlir::emitError(loc)
          << "unsupported expression: range select with non-constant bounds";
      return {};
    }
 
    // We need to determine the right bound of the range. This is the address of
    // the least significant bit of the underlying bit storage, which is the
    // offset we want to pass to the extract op.
    //
    // The arrays [6:2] and [2:6] both have 5 bits worth of underlying storage.
    // The left and right bound of the range only determine the addressing
    // scheme of the storage bits:
    //
    // Storage bits:   4  3  2  1  0  <-- extract op works on storage bits
    // [6:2] indices:  6  5  4  3  2  ("little endian" in Slang terms)
    // [2:6] indices:  2  3  4  5  6  ("big endian" in Slang terms)
    //
    // Before we can extract, we need to map the range select left and right
    // bounds from these indices to actual bit positions in the storage.
 
    Value offsetDyn;
    int32_t offsetConst = 0;
    auto range = expr.value().type->getFixedRange();
 
    using slang::ast::RangeSelectionKind;
    if (expr.getSelectionKind() == RangeSelectionKind::Simple) {
      // For a constant range [a:b], we want the offset of the lowest storage
      // bit from which we are starting the extract. For a range [5:3] this is
      // bit index 3; for a range [3:5] this is bit index 5. Both of these are
      // later translated map to bit offset 1 (see bit indices above).
      assert(constRight && "constness checked in slang");
      offsetConst = *constRight;
    } else {
      // For an indexed range [a+:b] or [a-:b], determining the lowest storage
      // bit is a bit more complicated. We start out with the base index `a`.
      // This is the lower *index* of the range, but not the lower *storage bit
      // position*.
      //
      // The range [a+:b] expands to [a+b-1:a] for a [6:2] range, or [a:a+b-1]
      // for a [2:6] range. The range [a-:b] expands to [a:a-b+1] for a [6:2]
      // range, or [a-b+1:a] for a [2:6] range.
      if (constLeft) {
        offsetConst = *constLeft;
      } else {
        offsetDyn = context.convertRvalueExpression(expr.left());
        if (!offsetDyn)
          return {};
      }
 
      // For a [a-:b] select on [2:6] and a [a+:b] select on [6:2], the range
      // expands to [a-b+1:a] and [a+b-1:a]. In this case, the right bound which
      // corresponds to the lower *storage bit offset*, is just `a` and there's
      // no further tweaking to do.
      int32_t offsetAdd = 0;
 
      // For a [a-:b] select on [6:2], the range expands to [a:a-b+1]. We
      // therefore have to take the `a` from above and adjust it by `-b+1` to
      // arrive at the right bound.
      if (expr.getSelectionKind() == RangeSelectionKind::IndexedDown &&
          range.isDescending()) {
        assert(constRight && "constness checked in slang");
        offsetAdd = 1 - *constRight;
      }
 
      // For a [a+:b] select on [2:6], the range expands to [a:a+b-1]. We
      // therefore have to take the `a` from above and adjust it by `+b-1` to
      // arrive at the right bound.
      if (expr.getSelectionKind() == RangeSelectionKind::IndexedUp &&
          !range.isDescending()) {
        assert(constRight && "constness checked in slang");
        offsetAdd = *constRight - 1;
      }
 
      // Adjust the offset such that it matches the right bound of the range.
      if (offsetAdd != 0) {
        if (offsetDyn)
          offsetDyn = moore::AddOp::create(
              builder, loc, offsetDyn,
              moore::ConstantOp::create(
                  builder, loc, cast<moore::IntType>(offsetDyn.getType()),
                  offsetAdd,
                  /*isSigned=*/offsetAdd < 0));
        else
          offsetConst += offsetAdd;
      }
    }
 
    // Create a dynamic or constant extract. Use `getSelectIndex` and
    // `ConstantRange::translateIndex` to map from the bit indices provided by
    // the user to the actual storage bit position. Since `offset*` corresponds
    // to the right bound of the range, which provides the index of the least
    // significant selected storage bit, we get the bit offset at which we want
    // to start extracting.
    auto resultType =
        isLvalue ? moore::RefType::get(cast<moore::UnpackedType>(type)) : type;
 
    if (offsetDyn) {
      offsetDyn = getSelectIndex(context, loc, offsetDyn, range);
      if (isLvalue)
        return moore::DynExtractRefOp::create(builder, loc, resultType, value,
                                              offsetDyn);
      return moore::DynExtractOp::create(builder, loc, resultType, value,
                                         offsetDyn);
    }
    offsetConst = range.translateIndex(offsetConst);
    if (isLvalue)
      return moore::ExtractRefOp::create(builder, loc, resultType, value,
                                         offsetConst);
    return moore::ExtractOp::create(builder, loc, resultType, value,
                                    offsetConst);
  }
 
  /// Handle concatenations.
  Value visit(const slang::ast::ConcatenationExpression &expr) {
    SmallVector<Value> operands;
    if (expr.type->isString()) {
      for (auto *operand : expr.operands()) {
        assert(!isLvalue && "checked by Slang");
        auto value = convertLvalueOrRvalueExpression(*operand);
        if (!value)
          return {};
        value = context.materializeConversion(
            moore::StringType::get(context.getContext()), value, false,
            value.getLoc());
        if (!value)
          return {};
        operands.push_back(value);
      }
      return moore::StringConcatOp::create(builder, loc, operands);
    }
    if (expr.type->isQueue()) {
      return handleQueueConcat(expr);
    }
 
    if (expr.type->isUnpackedArray()) {
      assert(!isLvalue && "checked by Slang");
      auto loweredType = context.convertType(*expr.type, loc);
      if (!loweredType)
        return {};
 
      moore::UnpackedType elementType;
      if (auto arrayType = dyn_cast<moore::UnpackedArrayType>(loweredType))
        elementType = arrayType.getElementType();
      else if (auto openType =
                   dyn_cast<moore::OpenUnpackedArrayType>(loweredType))
        elementType = openType.getElementType();
      else
        return {};
 
      SmallVector<Value> operands;
      for (auto *operand : expr.operands()) {
        if (operand->type->isVoid())
          continue;
        auto value = context.convertRvalueExpression(*operand, elementType);
        if (!value)
          return {};
        operands.push_back(value);
      }
 
      auto arrayType = moore::UnpackedArrayType::get(
          context.getContext(), operands.size(), elementType);
      return moore::ArrayCreateOp::create(builder, loc, arrayType, operands);
    }
 
    for (auto *operand : expr.operands()) {
      // Handle empty replications like `{0{...}}` which may occur within
      // concatenations. Slang assigns them a `void` type which we can check for
      // here.
      if (operand->type->isVoid())
        continue;
      auto value = convertLvalueOrRvalueExpression(*operand);
      if (!value)
        return {};
      if (!isLvalue)
        value = context.convertToSimpleBitVector(value);
      if (!value)
        return {};
      operands.push_back(value);
    }
    if (isLvalue)
      return moore::ConcatRefOp::create(builder, loc, operands);
    return moore::ConcatOp::create(builder, loc, operands);
  }
 
  // Handles a `ConcatenationExpression` which produces a queue as a result.
  // Intuitively, queue concatenations are the same as unpacked array
  // concatenations. However, because queues may vary in size, we can't
  // just convert each argument to a simple bit vector.
  Value handleQueueConcat(const slang::ast::ConcatenationExpression &expr) {
    SmallVector<Value> operands;
 
    auto queueType =
        cast<moore::QueueType>(context.convertType(*expr.type, loc));
    auto elementType = queueType.getElementType();
 
    // Strategy:
    // QueueConcatOp only takes queues, so other types must be converted to
    // queues.
    // - Unpacked arrays have a conversion to queues via
    // `QueueFromUnpackedArrayOp`.
    // - For individual elements, we create a new queue for each contiguous
    // sequence of elements, and add this to the QueueConcatOp.
 
    // The current contiguous sequence of individual elements.
    Value contigElements;
 
    for (auto *operand : expr.operands()) {
      bool isSingleElement =
          context.convertType(*operand->type, loc) == elementType;
 
      // If the subsequent operand is not a single element, add the current
      // sequence of contiguous elements to the QueueConcatOp
      if (!isSingleElement && contigElements) {
        operands.push_back(moore::ReadOp::create(builder, loc, contigElements));
        contigElements = {};
      }
 
      assert(!isLvalue && "checked by Slang");
      auto value = convertLvalueOrRvalueExpression(*operand);
      if (!value)
        return {};
 
      // If value is an element of the queue, create an empty queue and add
      // that element.
      if (value.getType() == elementType) {
        auto queueRefType =
            moore::RefType::get(context.getContext(), queueType);
 
        if (!contigElements) {
          contigElements =
              moore::VariableOp::create(builder, loc, queueRefType, {}, {});
        }
        moore::QueuePushBackOp::create(builder, loc, contigElements, value);
        continue;
      }
 
      // Otherwise, the value should be directly convertible to a queue type.
      // If the type is a queue type with the same element type, skip this step,
      // since we don't need to cast things like queue<T, 10> to queue<T, 0>,
      // - QueueConcatOp doesn't mind the queue bounds.
      if (!(isa<moore::QueueType>(value.getType()) &&
            cast<moore::QueueType>(value.getType()).getElementType() ==
                elementType)) {
        value = context.materializeConversion(queueType, value, false,
                                              value.getLoc());
        if (!value)
          return {};
      }
 
      operands.push_back(value);
    }
 
    if (contigElements) {
      operands.push_back(moore::ReadOp::create(builder, loc, contigElements));
    }
 
    return moore::QueueConcatOp::create(builder, loc, queueType, operands);
  }
 
  /// Handle member accesses.
  Value visit(const slang::ast::MemberAccessExpression &expr) {
    auto type = context.convertType(*expr.type);
    if (!type)
      return {};
 
    auto *valueType = expr.value().type.get();
    auto memberName = builder.getStringAttr(expr.member.name);
 
    // Handle virtual interfaces. We represent virtual interface handles as a
    // Moore struct containing references to interface members. Member access
    // returns the stored reference directly (for lvalues) or reads it (for
    // rvalues).
    if (valueType->isVirtualInterface()) {
      auto memberType = dyn_cast<moore::UnpackedType>(type);
      if (!memberType) {
        mlir::emitError(loc)
            << "unsupported virtual interface member type: " << type;
        return {};
      }
      auto resultRefType = moore::RefType::get(memberType);
 
      // Always use the rvalue of the base handle to avoid creating
      // ref<ref<T>> for lvalue member access.
      Value base = context.convertRvalueExpression(expr.value());
      if (!base)
        return {};
 
      auto memberRef = moore::StructExtractOp::create(
          builder, loc, resultRefType, memberName, base);
      if (isLvalue)
        return memberRef;
      return moore::ReadOp::create(builder, loc, memberRef);
    }
 
    // Handle structs.
    if (valueType->isStruct()) {
      auto resultType =
          isLvalue ? moore::RefType::get(cast<moore::UnpackedType>(type))
                   : type;
      auto value = convertLvalueOrRvalueExpression(expr.value());
      if (!value)
        return {};
 
      if (isLvalue)
        return moore::StructExtractRefOp::create(builder, loc, resultType,
                                                 memberName, value);
      return moore::StructExtractOp::create(builder, loc, resultType,
                                            memberName, value);
    }
 
    // Handle unions.
    if (valueType->isPackedUnion() || valueType->isUnpackedUnion()) {
      auto resultType =
          isLvalue ? moore::RefType::get(cast<moore::UnpackedType>(type))
                   : type;
      auto value = convertLvalueOrRvalueExpression(expr.value());
      if (!value)
        return {};
 
      if (isLvalue)
        return moore::UnionExtractRefOp::create(builder, loc, resultType,
                                                memberName, value);
      return moore::UnionExtractOp::create(builder, loc, type, memberName,
                                           value);
    }
 
    // Handle classes.
    if (valueType->isClass()) {
      auto valTy = context.convertType(*valueType);
      if (!valTy)
        return {};
      auto targetTy = cast<moore::ClassHandleType>(valTy);
 
      // `MemberAccessExpression`s may refer to either variables that may or may
      // not be compile time constants, or to class parameters which are always
      // elaboration-time constant.
      //
      // We distinguish these cases, and materialize a runtime member access
      // for variables, but force constant conversion for parameter accesses.
      //
      // Also see this discussion:
      // https://github.com/MikePopoloski/slang/issues/1641
 
      if (expr.member.kind != slang::ast::SymbolKind::Parameter) {
 
        // We need to pick the closest ancestor that declares a property with
        // the relevant name. System Verilog explicitly enforces lexical
        // shadowing, as shown in IEEE 1800-2023 Section 8.14 "Overridden
        // members".
        moore::ClassHandleType upcastTargetTy =
            context.getAncestorClassWithProperty(targetTy, expr.member.name,
                                                 loc);
        if (!upcastTargetTy)
          return {};
 
        // Convert the class handle to the required target type for property
        // shadowing purposes.
        Value baseVal =
            context.convertRvalueExpression(expr.value(), upcastTargetTy);
        if (!baseVal)
          return {};
 
        // @field and result type !moore.ref<T>.
        auto fieldSym = mlir::FlatSymbolRefAttr::get(builder.getContext(),
                                                     expr.member.name);
        auto fieldRefTy = moore::RefType::get(cast<moore::UnpackedType>(type));
 
        // Produce a ref to the class property from the (possibly upcast)
        // handle.
        Value fieldRef = moore::ClassPropertyRefOp::create(
            builder, loc, fieldRefTy, baseVal, fieldSym);
 
        // If we need an RValue, read the reference, otherwise return
        return isLvalue ? fieldRef
                        : moore::ReadOp::create(builder, loc, fieldRef);
      }
 
      slang::ConstantValue constVal;
      if (auto param = expr.member.as_if<slang::ast::ParameterSymbol>()) {
        constVal = param->getValue();
        if (auto value = context.materializeConstant(constVal, *expr.type, loc))
          return value;
      }
 
      mlir::emitError(loc) << "Parameter " << expr.member.name
                           << " has no constant value";
      return {};
    }
 
    mlir::emitError(loc, "expression of type ")
        << valueType->toString() << " has no member fields";
    return {};
  }
};
} // namespace
 
//===----------------------------------------------------------------------===//
// Rvalue Conversion
//===----------------------------------------------------------------------===//
 
// NOLINTBEGIN(misc-no-recursion)
namespace {
struct RvalueExprVisitor : public ExprVisitor {
  RvalueExprVisitor(Context &context, Location loc)
      : ExprVisitor(context, loc, /*isLvalue=*/false) {}
  using ExprVisitor::visit;
 
  // Handle references to the left-hand side of a parent assignment.
  Value visit(const slang::ast::LValueReferenceExpression &expr) {
    assert(!context.lvalueStack.empty() && "parent assignments push lvalue");
    auto lvalue = context.lvalueStack.back();
    return moore::ReadOp::create(builder, loc, lvalue);
  }
 
  // Handle named values, such as references to declared variables.
  Value visit(const slang::ast::NamedValueExpression &expr) {
    // Handle local variables.
    if (auto value = context.valueSymbols.lookup(&expr.symbol)) {
      if (isa<moore::RefType>(value.getType())) {
        auto readOp = moore::ReadOp::create(builder, loc, value);
        if (context.rvalueReadCallback)
          context.rvalueReadCallback(readOp);
        value = readOp.getResult();
      }
      return value;
    }
 
    // Handle global variables.
    if (auto globalOp = context.globalVariables.lookup(&expr.symbol)) {
      auto value = moore::GetGlobalVariableOp::create(builder, loc, globalOp);
      return moore::ReadOp::create(builder, loc, value);
    }
 
    // We're reading a class property.
    if (auto *const property =
            expr.symbol.as_if<slang::ast::ClassPropertySymbol>()) {
      auto fieldRef = visitClassProperty(context, *property);
      return moore::ReadOp::create(builder, loc, fieldRef).getResult();
    }
 
    // Slang may resolve `vif.member` accesses (with `vif` being a virtual
    // interface handle) directly to a NamedValueExpression for `member`.
    // Reconstruct the virtual interface access by consulting the mapping
    // populated at declaration sites.
    if (auto access = context.virtualIfaceMembers.lookup(&expr.symbol);
        access.base) {
      auto type = context.convertType(*expr.type);
      if (!type)
        return {};
      auto memberType = dyn_cast<moore::UnpackedType>(type);
      if (!memberType) {
        mlir::emitError(loc)
            << "unsupported virtual interface member type: " << type;
        return {};
      }
 
      Value base = materializeSymbolRvalue(*access.base);
      if (!base) {
        auto d = mlir::emitError(loc, "unknown name `")
                 << access.base->name << "`";
        d.attachNote(context.convertLocation(access.base->location))
            << "no rvalue generated for virtual interface base";
        return {};
      }
 
      auto fieldName = access.fieldName
                           ? access.fieldName
                           : builder.getStringAttr(expr.symbol.name);
      auto memberRefType = moore::RefType::get(memberType);
      auto memberRef = moore::StructExtractOp::create(
          builder, loc, memberRefType, fieldName, base);
      auto readOp = moore::ReadOp::create(builder, loc, memberRef);
      if (context.rvalueReadCallback)
        context.rvalueReadCallback(readOp);
      return readOp.getResult();
    }
 
    // Try to materialize constant values directly.
    auto constant = context.evaluateConstant(expr);
    if (auto value = context.materializeConstant(constant, *expr.type, loc))
      return value;
 
    // Otherwise some other part of ImportVerilog should have added an MLIR
    // value for this expression's symbol to the `context.valueSymbols` table.
    auto d = mlir::emitError(loc, "unknown name `") << expr.symbol.name << "`";
    d.attachNote(context.convertLocation(expr.symbol.location))
        << "no rvalue generated for " << slang::ast::toString(expr.symbol.kind);
    return {};
  }
 
  // Handle hierarchical values, such as `x = Top.sub.var`.
  Value visit(const slang::ast::HierarchicalValueExpression &expr) {
    auto hierLoc = context.convertLocation(expr.symbol.location);
 
    // Canonicalize self-references (e.g., SubD.z inside SubD) to local
    // variable lookups. When the hierarchical path's first instance body
    // is the same module that declares the target symbol, the reference
    // is intra-module and should resolve to the local variable directly.
    if (!expr.ref.path.empty()) {
      if (auto *inst = expr.ref.path.front()
                           .symbol->as_if<slang::ast::InstanceSymbol>()) {
        auto *symbolBody =
            expr.symbol.getParentScope()->getContainingInstance();
        if (&inst->body == symbolBody ||
            (symbolBody && inst->body.getDeclaringDefinition() ==
                               symbolBody->getDeclaringDefinition())) {
          if (auto value = context.valueSymbols.lookup(&expr.symbol)) {
            if (isa<moore::RefType>(value.getType())) {
              auto readOp = moore::ReadOp::create(builder, hierLoc, value);
              if (context.rvalueReadCallback)
                context.rvalueReadCallback(readOp);
              value = readOp.getResult();
            }
            return value;
          }
        }
      }
    }
 
    // Inside a function body, a captured symbol must resolve to the capture
    // argument to respect region isolation.
    if (auto value = context.resolveCapturedValue(expr.symbol)) {
      if (isa<moore::RefType>(value.getType())) {
        auto readOp = moore::ReadOp::create(builder, hierLoc, value);
        if (context.rvalueReadCallback)
          context.rvalueReadCallback(readOp);
        value = readOp.getResult();
      }
      return value;
    }
 
    // For cross-instance hierarchical references, prefer the isntance-aware
    // hierValueSymbols lookup. Sibling instances elaborate distinct symbol
    // objects for the same logical variable, and this map keeps p1 vs p2
    // resolutions separate where the scoped table could conflate them.
    if (auto key = context.buildHierValueKey(expr)) {
      if (auto it = context.hierValueSymbols.find(*key);
          it != context.hierValueSymbols.end()) {
        auto value = it->second;
        if (isa<moore::RefType>(value.getType())) {
          auto readOp = moore::ReadOp::create(builder, hierLoc, value);
          if (context.rvalueReadCallback)
            context.rvalueReadCallback(readOp);
          value = readOp.getResult();
        }
        return value;
      }
    }
 
    // Fall back to scoped symbol table (same-scope lookups, self-refs).
    if (auto value = context.valueSymbols.lookup(&expr.symbol)) {
      if (isa<moore::RefType>(value.getType())) {
        auto readOp = moore::ReadOp::create(builder, hierLoc, value);
        if (context.rvalueReadCallback)
          context.rvalueReadCallback(readOp);
        value = readOp.getResult();
      }
      return value;
    }
 
    if (auto value = lookupExpandedInterfaceMember(context, expr)) {
      if (isa<moore::RefType>(value.getType())) {
        auto readOp = moore::ReadOp::create(builder, hierLoc, value);
        if (context.rvalueReadCallback)
          context.rvalueReadCallback(readOp);
        return readOp.getResult();
      }
      return value;
    }
 
    /// Materialize compile-time constants directly from the symbol: the
    /// generic evaluateConstant refuses hierarchical references unless slang's
    /// AllowHierarchicalConst flag is set, which CIRCT does not use.
    slang::ConstantValue constant;
    switch (expr.symbol.kind) {
    case slang::ast::SymbolKind::Parameter:
      constant = expr.symbol.as<slang::ast::ParameterSymbol>().getValue(
          expr.sourceRange);
      break;
    case slang::ast::SymbolKind::Specparam:
      constant = expr.symbol.as<slang::ast::SpecparamSymbol>().getValue(
          expr.sourceRange);
      break;
    case slang::ast::SymbolKind::EnumValue:
      constant = expr.symbol.as<slang::ast::EnumValueSymbol>().getValue(
          expr.sourceRange);
      break;
    default:
      constant = context.evaluateConstant(expr);
      break;
    }
    if (auto value = context.materializeConstant(constant, *expr.type, loc))
      return value;
 
    // Emit an error for those hierarchical values not recorded in the
    // `valueSymbols`.
    auto d = mlir::emitError(loc, "unknown hierarchical name `")
             << expr.symbol.name << "`";
    d.attachNote(hierLoc) << "no rvalue generated for "
                          << slang::ast::toString(expr.symbol.kind);
    return {};
  }
 
  // Handle arbitrary symbol references. Slang uses this expression to represent
  // "real" interface instances in virtual interface assignments.
  Value visit(const slang::ast::ArbitrarySymbolExpression &expr) {
    const auto &canonTy = expr.type->getCanonicalType();
    if (const auto *vi = canonTy.as_if<slang::ast::VirtualInterfaceType>()) {
      auto value = context.materializeVirtualInterfaceValue(*vi, loc);
      if (failed(value))
        return {};
      return *value;
    }
 
    mlir::emitError(loc) << "unsupported arbitrary symbol expression of type "
                         << expr.type->toString();
    return {};
  }
 
  // Handle type conversions (explicit and implicit).
  Value visit(const slang::ast::ConversionExpression &expr) {
    auto type = context.convertType(*expr.type);
    if (!type)
      return {};
    return context.convertRvalueExpression(expr.operand(), type);
  }
 
  // Handle blocking and non-blocking assignments.
  Value visit(const slang::ast::AssignmentExpression &expr) {
    auto lhs = context.convertLvalueExpression(expr.left());
    if (!lhs)
      return {};
 
    // Determine the right-hand side value of the assignment.
    context.lvalueStack.push_back(lhs);
    auto rhs = context.convertRvalueExpression(
        expr.right(), cast<moore::RefType>(lhs.getType()).getNestedType());
    context.lvalueStack.pop_back();
    if (!rhs)
      return {};
 
    // If this is a blocking assignment, we can insert the delay/wait ops of the
    // optional timing control directly in between computing the RHS and
    // executing the assignment.
    if (!expr.isNonBlocking()) {
      if (expr.timingControl)
        if (failed(context.convertTimingControl(*expr.timingControl)))
          return {};
      auto assignOp = moore::BlockingAssignOp::create(builder, loc, lhs, rhs);
      if (context.variableAssignCallback)
        context.variableAssignCallback(assignOp);
      return rhs;
    }
 
    // For non-blocking assignments, we only support time delays for now.
    if (expr.timingControl) {
      // Handle regular time delays.
      if (auto *ctrl = expr.timingControl->as_if<slang::ast::DelayControl>()) {
        auto delay = context.convertRvalueExpression(
            ctrl->expr, moore::TimeType::get(builder.getContext()));
        if (!delay)
          return {};
        auto assignOp = moore::DelayedNonBlockingAssignOp::create(
            builder, loc, lhs, rhs, delay);
        if (context.variableAssignCallback)
          context.variableAssignCallback(assignOp);
        return rhs;
      }
 
      // All other timing controls are not supported.
      auto loc = context.convertLocation(expr.timingControl->sourceRange);
      mlir::emitError(loc)
          << "unsupported non-blocking assignment timing control: "
          << slang::ast::toString(expr.timingControl->kind);
      return {};
    }
    auto assignOp = moore::NonBlockingAssignOp::create(builder, loc, lhs, rhs);
    if (context.variableAssignCallback)
      context.variableAssignCallback(assignOp);
    return rhs;
  }
 
  // Helper function to convert an argument to a simple bit vector type, pass it
  // to a reduction op, and optionally invert the result.
  template <class ConcreteOp>
  Value createReduction(Value arg, bool invert) {
    arg = context.convertToSimpleBitVector(arg);
    if (!arg)
      return {};
    Value result = ConcreteOp::create(builder, loc, arg);
    if (invert)
      result = moore::NotOp::create(builder, loc, result);
    return result;
  }
 
  // Helper function to create pre and post increments and decrements.
  Value createIncrement(Value arg, bool isInc, bool isPost) {
    auto preValue = moore::ReadOp::create(builder, loc, arg);
    Value postValue;
    // Catch the special case where a signed 1 bit value (i1) is incremented,
    // as +1 can not be expressed as a signed 1 bit value. For any 1-bit number
    // negating is equivalent to incrementing.
    if (moore::isIntType(preValue.getType(), 1)) {
      postValue = moore::NotOp::create(builder, loc, preValue).getResult();
    } else {
 
      auto one = moore::ConstantOp::create(
          builder, loc, cast<moore::IntType>(preValue.getType()), 1);
      postValue =
          isInc ? moore::AddOp::create(builder, loc, preValue, one).getResult()
                : moore::SubOp::create(builder, loc, preValue, one).getResult();
      auto assignOp =
          moore::BlockingAssignOp::create(builder, loc, arg, postValue);
      if (context.variableAssignCallback)
        context.variableAssignCallback(assignOp);
    }
 
    if (isPost)
      return preValue;
    return postValue;
  }
 
  // Helper function to create pre and post increments and decrements.
  Value createRealIncrement(Value arg, bool isInc, bool isPost) {
    Value preValue = moore::ReadOp::create(builder, loc, arg);
    Value postValue;
 
    bool isTime = isa<moore::TimeType>(preValue.getType());
    if (isTime)
      preValue = context.materializeConversion(
          moore::RealType::get(context.getContext(), moore::RealWidth::f64),
          preValue, false, loc);
 
    moore::RealType realTy =
        llvm::dyn_cast<moore::RealType>(preValue.getType());
    if (!realTy)
      return {};
 
    FloatAttr oneAttr;
    if (realTy.getWidth() == moore::RealWidth::f32) {
      oneAttr = builder.getFloatAttr(builder.getF32Type(), 1.0);
    } else if (realTy.getWidth() == moore::RealWidth::f64) {
      auto oneVal = isTime ? getTimeScaleInFemtoseconds(context) : 1.0;
      oneAttr = builder.getFloatAttr(builder.getF64Type(), oneVal);
    } else {
      mlir::emitError(loc) << "cannot construct increment for " << realTy;
      return {};
    }
    auto one = moore::ConstantRealOp::create(builder, loc, oneAttr);
 
    postValue =
        isInc
            ? moore::AddRealOp::create(builder, loc, preValue, one).getResult()
            : moore::SubRealOp::create(builder, loc, preValue, one).getResult();
 
    if (isTime)
      postValue = context.materializeConversion(
          moore::TimeType::get(context.getContext()), postValue, false, loc);
 
    auto assignOp =
        moore::BlockingAssignOp::create(builder, loc, arg, postValue);
 
    if (context.variableAssignCallback)
      context.variableAssignCallback(assignOp);
 
    if (isPost)
      return preValue;
    return postValue;
  }
 
  Value visitRealUOp(const slang::ast::UnaryExpression &expr) {
    Type opFTy = context.convertType(*expr.operand().type);
 
    using slang::ast::UnaryOperator;
    Value arg;
    if (expr.op == UnaryOperator::Preincrement ||
        expr.op == UnaryOperator::Predecrement ||
        expr.op == UnaryOperator::Postincrement ||
        expr.op == UnaryOperator::Postdecrement)
      arg = context.convertLvalueExpression(expr.operand());
    else
      arg = context.convertRvalueExpression(expr.operand(), opFTy);
    if (!arg)
      return {};
 
    // Only covers expressions in 'else' branch above.
    if (isa<moore::TimeType>(arg.getType()))
      arg = context.materializeConversion(
          moore::RealType::get(context.getContext(), moore::RealWidth::f64),
          arg, false, loc);
 
    switch (expr.op) {
      // `+a` is simply `a`
    case UnaryOperator::Plus:
      return arg;
    case UnaryOperator::Minus:
      return moore::NegRealOp::create(builder, loc, arg);
 
    case UnaryOperator::Preincrement:
      return createRealIncrement(arg, true, false);
    case UnaryOperator::Predecrement:
      return createRealIncrement(arg, false, false);
    case UnaryOperator::Postincrement:
      return createRealIncrement(arg, true, true);
    case UnaryOperator::Postdecrement:
      return createRealIncrement(arg, false, true);
 
    case UnaryOperator::LogicalNot:
      arg = context.convertToBool(arg);
      if (!arg)
        return {};
      return moore::NotOp::create(builder, loc, arg);
 
    default:
      mlir::emitError(loc) << "Unary operator " << slang::ast::toString(expr.op)
                           << " not supported with real values!\n";
      return {};
    }
  }
 
  // Handle unary operators.
  Value visit(const slang::ast::UnaryExpression &expr) {
    // First check whether we need real or integral BOps
    const auto *floatType =
        expr.operand().type->as_if<slang::ast::FloatingType>();
    // If op is real-typed, treat as real BOp.
    if (floatType)
      return visitRealUOp(expr);
 
    using slang::ast::UnaryOperator;
    Value arg;
    if (expr.op == UnaryOperator::Preincrement ||
        expr.op == UnaryOperator::Predecrement ||
        expr.op == UnaryOperator::Postincrement ||
        expr.op == UnaryOperator::Postdecrement)
      arg = context.convertLvalueExpression(expr.operand());
    else
      arg = context.convertRvalueExpression(expr.operand());
    if (!arg)
      return {};
 
    switch (expr.op) {
      // `+a` is simply `a`, but converted to a simple bit vector type since
      // this is technically an arithmetic operation.
    case UnaryOperator::Plus:
      return context.convertToSimpleBitVector(arg);
 
    case UnaryOperator::Minus:
      arg = context.convertToSimpleBitVector(arg);
      if (!arg)
        return {};
      return moore::NegOp::create(builder, loc, arg);
 
    case UnaryOperator::BitwiseNot:
      arg = context.convertToSimpleBitVector(arg);
      if (!arg)
        return {};
      return moore::NotOp::create(builder, loc, arg);
 
    case UnaryOperator::BitwiseAnd:
      return createReduction<moore::ReduceAndOp>(arg, false);
    case UnaryOperator::BitwiseOr:
      return createReduction<moore::ReduceOrOp>(arg, false);
    case UnaryOperator::BitwiseXor:
      return createReduction<moore::ReduceXorOp>(arg, false);
    case UnaryOperator::BitwiseNand:
      return createReduction<moore::ReduceAndOp>(arg, true);
    case UnaryOperator::BitwiseNor:
      return createReduction<moore::ReduceOrOp>(arg, true);
    case UnaryOperator::BitwiseXnor:
      return createReduction<moore::ReduceXorOp>(arg, true);
 
    case UnaryOperator::LogicalNot:
      arg = context.convertToBool(arg);
      if (!arg)
        return {};
      return moore::NotOp::create(builder, loc, arg);
 
    case UnaryOperator::Preincrement:
      return createIncrement(arg, true, false);
    case UnaryOperator::Predecrement:
      return createIncrement(arg, false, false);
    case UnaryOperator::Postincrement:
      return createIncrement(arg, true, true);
    case UnaryOperator::Postdecrement:
      return createIncrement(arg, false, true);
    }
 
    mlir::emitError(loc, "unsupported unary operator");
    return {};
  }
 
  /// Handles logical operators (§11.4.7), assuming lhs/rhs are rvalues already.
  Value buildLogicalBOp(slang::ast::BinaryOperator op, Value lhs, Value rhs,
                        std::optional<Domain> domain = std::nullopt) {
    using slang::ast::BinaryOperator;
    // TODO: These should short-circuit; RHS should be in a separate block.
 
    if (domain) {
      lhs = context.convertToBool(lhs, domain.value());
      rhs = context.convertToBool(rhs, domain.value());
    } else {
      lhs = context.convertToBool(lhs);
      rhs = context.convertToBool(rhs);
    }
 
    if (!lhs || !rhs)
      return {};
 
    switch (op) {
    case BinaryOperator::LogicalAnd:
      return moore::AndOp::create(builder, loc, lhs, rhs);
 
    case BinaryOperator::LogicalOr:
      return moore::OrOp::create(builder, loc, lhs, rhs);
 
    case BinaryOperator::LogicalImplication: {
      // (lhs -> rhs) == (!lhs || rhs)
      auto notLHS = moore::NotOp::create(builder, loc, lhs);
      return moore::OrOp::create(builder, loc, notLHS, rhs);
    }
 
    case BinaryOperator::LogicalEquivalence: {
      // (lhs <-> rhs) == (lhs && rhs) || (!lhs && !rhs)
      auto notLHS = moore::NotOp::create(builder, loc, lhs);
      auto notRHS = moore::NotOp::create(builder, loc, rhs);
      auto both = moore::AndOp::create(builder, loc, lhs, rhs);
      auto notBoth = moore::AndOp::create(builder, loc, notLHS, notRHS);
      return moore::OrOp::create(builder, loc, both, notBoth);
    }
 
    default:
      llvm_unreachable("not a logical BinaryOperator");
    }
  }
 
  Value visitHandleBOp(const slang::ast::BinaryExpression &expr) {
    // Convert operands to the chosen target type.
    auto lhs = context.convertRvalueExpression(expr.left());
    if (!lhs)
      return {};
    auto rhs = context.convertRvalueExpression(expr.right());
    if (!rhs)
      return {};
 
    using slang::ast::BinaryOperator;
    switch (expr.op) {
 
    case BinaryOperator::Equality:
      return moore::HandleEqOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::Inequality:
      return moore::HandleNeOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::CaseEquality:
      return moore::HandleCaseEqOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::CaseInequality:
      return moore::HandleCaseNeOp::create(builder, loc, lhs, rhs);
 
    default:
      mlir::emitError(loc)
          << "Binary operator " << slang::ast::toString(expr.op)
          << " not supported with class handle valued operands!\n";
      return {};
    }
  }
 
  Value visitRealBOp(const slang::ast::BinaryExpression &expr) {
    // Convert operands to the chosen target type.
    auto lhs = context.convertRvalueExpression(expr.left());
    if (!lhs)
      return {};
    auto rhs = context.convertRvalueExpression(expr.right());
    if (!rhs)
      return {};
 
    if (isa<moore::TimeType>(lhs.getType()) ||
        isa<moore::TimeType>(rhs.getType())) {
      lhs = context.materializeConversion(
          moore::RealType::get(context.getContext(), moore::RealWidth::f64),
          lhs, false, loc);
      rhs = context.materializeConversion(
          moore::RealType::get(context.getContext(), moore::RealWidth::f64),
          rhs, false, loc);
    }
 
    using slang::ast::BinaryOperator;
    switch (expr.op) {
    case BinaryOperator::Add:
      return moore::AddRealOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::Subtract:
      return moore::SubRealOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::Multiply:
      return moore::MulRealOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::Divide:
      return moore::DivRealOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::Power:
      return moore::PowRealOp::create(builder, loc, lhs, rhs);
 
    case BinaryOperator::Equality:
      return moore::EqRealOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::Inequality:
      return moore::NeRealOp::create(builder, loc, lhs, rhs);
 
    case BinaryOperator::GreaterThan:
      return moore::FgtOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::LessThan:
      return moore::FltOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::GreaterThanEqual:
      return moore::FgeOp::create(builder, loc, lhs, rhs);
    case BinaryOperator::LessThanEqual:
      return moore::FleOp::create(builder, loc, lhs, rhs);
 
    case BinaryOperator::LogicalAnd:
    case BinaryOperator::LogicalOr:
    case BinaryOperator::LogicalImplication:
    case BinaryOperator::LogicalEquivalence: {
      Domain domain = Domain::TwoValued;
      if (expr.left().type->isFourState() || expr.right().type->isFourState())
        domain = Domain::FourValued;
      return buildLogicalBOp(expr.op, lhs, rhs, domain);
    }
 
    default:
      mlir::emitError(loc) << "Binary operator "
                           << slang::ast::toString(expr.op)
                           << " not supported with real valued operands!\n";
      return {};
    }
  }
 
  // Helper function to convert two arguments to a simple bit vector type and
  // pass them into a binary op.
  template <class ConcreteOp>
  Value createBinary(Value lhs, Value rhs) {
    lhs = context.convertToSimpleBitVector(lhs);
    if (!lhs)
      return {};
    rhs = context.convertToSimpleBitVector(rhs);
    if (!rhs)
      return {};
    return ConcreteOp::create(builder, loc, lhs, rhs);
  }
 
  // Handle binary operators.
  Value visit(const slang::ast::BinaryExpression &expr) {
    if (expr.left().kind == slang::ast::ExpressionKind::TypeReference &&
        expr.right().kind == slang::ast::ExpressionKind::TypeReference) {
      auto &lhsType =
          expr.left().as<slang::ast::TypeReferenceExpression>().targetType;
      auto &rhsType =
          expr.right().as<slang::ast::TypeReferenceExpression>().targetType;
      bool value = lhsType.isMatching(rhsType);
 
      using slang::ast::BinaryOperator;
      switch (expr.op) {
      case BinaryOperator::Equality:
      case BinaryOperator::CaseEquality:
        break;
      case BinaryOperator::Inequality:
      case BinaryOperator::CaseInequality:
        value = !value;
        break;
      default:
        mlir::emitError(loc, "unsupported type reference binary operator");
        return {};
      }
 
      auto type = moore::IntType::get(context.getContext(), /*width=*/1,
                                      moore::Domain::TwoValued);
      return moore::ConstantOp::create(builder, loc, type, value,
                                       /*isSigned=*/false);
    }
 
    // First check whether we need real or integral BOps
    const auto *rhsFloatType =
        expr.right().type->as_if<slang::ast::FloatingType>();
    const auto *lhsFloatType =
        expr.left().type->as_if<slang::ast::FloatingType>();
 
    // If either arg is real-typed, treat as real BOp.
    if (rhsFloatType || lhsFloatType)
      return visitRealBOp(expr);
 
    // Check whether we are comparing against a Class Handle or CHandle
    const auto rhsIsClass = expr.right().type->isClass();
    const auto lhsIsClass = expr.left().type->isClass();
    const auto rhsIsChandle = expr.right().type->isCHandle();
    const auto lhsIsChandle = expr.left().type->isCHandle();
    // If either arg is class handle-typed, treat as class handle BOp.
    if (rhsIsClass || lhsIsClass || rhsIsChandle || lhsIsChandle)
      return visitHandleBOp(expr);
 
    auto lhs = context.convertRvalueExpression(expr.left());
    if (!lhs)
      return {};
    auto rhs = context.convertRvalueExpression(expr.right());
    if (!rhs)
      return {};
 
    // Determine the domain of the result.
    Domain domain = Domain::TwoValued;
    if (expr.type->isFourState() || expr.left().type->isFourState() ||
        expr.right().type->isFourState())
      domain = Domain::FourValued;
 
    using slang::ast::BinaryOperator;
    switch (expr.op) {
    case BinaryOperator::Add:
      return createBinary<moore::AddOp>(lhs, rhs);
    case BinaryOperator::Subtract:
      return createBinary<moore::SubOp>(lhs, rhs);
    case BinaryOperator::Multiply:
      return createBinary<moore::MulOp>(lhs, rhs);
    case BinaryOperator::Divide:
      if (expr.type->isSigned())
        return createBinary<moore::DivSOp>(lhs, rhs);
      else
        return createBinary<moore::DivUOp>(lhs, rhs);
    case BinaryOperator::Mod:
      if (expr.type->isSigned())
        return createBinary<moore::ModSOp>(lhs, rhs);
      else
        return createBinary<moore::ModUOp>(lhs, rhs);
    case BinaryOperator::Power: {
      // Slang casts the LHS and result of the `**` operator to a four-valued
      // type, since the operator can return X even for two-valued inputs. To
      // maintain uniform types across operands and results, cast the RHS to
      // that four-valued type as well.
      auto rhsCast = context.materializeConversion(
          lhs.getType(), rhs, expr.right().type->isSigned(), rhs.getLoc());
      if (expr.type->isSigned())
        return createBinary<moore::PowSOp>(lhs, rhsCast);
      return createBinary<moore::PowUOp>(lhs, rhsCast);
    }
 
    case BinaryOperator::BinaryAnd:
      return createBinary<moore::AndOp>(lhs, rhs);
    case BinaryOperator::BinaryOr:
      return createBinary<moore::OrOp>(lhs, rhs);
    case BinaryOperator::BinaryXor:
      return createBinary<moore::XorOp>(lhs, rhs);
    case BinaryOperator::BinaryXnor: {
      auto result = createBinary<moore::XorOp>(lhs, rhs);
      if (!result)
        return {};
      return moore::NotOp::create(builder, loc, result);
    }
 
    case BinaryOperator::Equality:
      if (isa<moore::UnpackedArrayType>(lhs.getType()))
        return moore::UArrayCmpOp::create(
            builder, loc, moore::UArrayCmpPredicate::eq, lhs, rhs);
      else if (isa<moore::StringType>(lhs.getType()))
        return moore::StringCmpOp::create(
            builder, loc, moore::StringCmpPredicate::eq, lhs, rhs);
      else if (isa<moore::QueueType>(lhs.getType()))
        return moore::QueueCmpOp::create(
            builder, loc, moore::UArrayCmpPredicate::eq, lhs, rhs);
      else
        return createBinary<moore::EqOp>(lhs, rhs);
    case BinaryOperator::Inequality:
      if (isa<moore::UnpackedArrayType>(lhs.getType()))
        return moore::UArrayCmpOp::create(
            builder, loc, moore::UArrayCmpPredicate::ne, lhs, rhs);
      else if (isa<moore::StringType>(lhs.getType()))
        return moore::StringCmpOp::create(
            builder, loc, moore::StringCmpPredicate::ne, lhs, rhs);
      else if (isa<moore::QueueType>(lhs.getType()))
        return moore::QueueCmpOp::create(
            builder, loc, moore::UArrayCmpPredicate::ne, lhs, rhs);
      else
        return createBinary<moore::NeOp>(lhs, rhs);
    case BinaryOperator::CaseEquality:
      return createBinary<moore::CaseEqOp>(lhs, rhs);
    case BinaryOperator::CaseInequality:
      return createBinary<moore::CaseNeOp>(lhs, rhs);
    case BinaryOperator::WildcardEquality:
      return createBinary<moore::WildcardEqOp>(lhs, rhs);
    case BinaryOperator::WildcardInequality:
      return createBinary<moore::WildcardNeOp>(lhs, rhs);
 
    case BinaryOperator::GreaterThanEqual:
      if (expr.left().type->isSigned())
        return createBinary<moore::SgeOp>(lhs, rhs);
      else if (isa<moore::StringType>(lhs.getType()))
        return moore::StringCmpOp::create(
            builder, loc, moore::StringCmpPredicate::ge, lhs, rhs);
      else
        return createBinary<moore::UgeOp>(lhs, rhs);
    case BinaryOperator::GreaterThan:
      if (expr.left().type->isSigned())
        return createBinary<moore::SgtOp>(lhs, rhs);
      else if (isa<moore::StringType>(lhs.getType()))
        return moore::StringCmpOp::create(
            builder, loc, moore::StringCmpPredicate::gt, lhs, rhs);
      else
        return createBinary<moore::UgtOp>(lhs, rhs);
    case BinaryOperator::LessThanEqual:
      if (expr.left().type->isSigned())
        return createBinary<moore::SleOp>(lhs, rhs);
      else if (isa<moore::StringType>(lhs.getType()))
        return moore::StringCmpOp::create(
            builder, loc, moore::StringCmpPredicate::le, lhs, rhs);
      else
        return createBinary<moore::UleOp>(lhs, rhs);
    case BinaryOperator::LessThan:
      if (expr.left().type->isSigned())
        return createBinary<moore::SltOp>(lhs, rhs);
      else if (isa<moore::StringType>(lhs.getType()))
        return moore::StringCmpOp::create(
            builder, loc, moore::StringCmpPredicate::lt, lhs, rhs);
      else
        return createBinary<moore::UltOp>(lhs, rhs);
 
    case BinaryOperator::LogicalAnd:
    case BinaryOperator::LogicalOr:
    case BinaryOperator::LogicalImplication:
    case BinaryOperator::LogicalEquivalence:
      return buildLogicalBOp(expr.op, lhs, rhs, domain);
 
    case BinaryOperator::LogicalShiftLeft:
      return createBinary<moore::ShlOp>(lhs, rhs);
    case BinaryOperator::LogicalShiftRight:
      return createBinary<moore::ShrOp>(lhs, rhs);
    case BinaryOperator::ArithmeticShiftLeft:
      return createBinary<moore::ShlOp>(lhs, rhs);
    case BinaryOperator::ArithmeticShiftRight: {
      // The `>>>` operator is an arithmetic right shift if the LHS operand is
      // signed, or a logical right shift if the operand is unsigned.
      lhs = context.convertToSimpleBitVector(lhs);
      rhs = context.convertToSimpleBitVector(rhs);
      if (!lhs || !rhs)
        return {};
      if (expr.type->isSigned())
        return moore::AShrOp::create(builder, loc, lhs, rhs);
      return moore::ShrOp::create(builder, loc, lhs, rhs);
    }
    }
 
    mlir::emitError(loc, "unsupported binary operator");
    return {};
  }
 
  // Handle `'0`, `'1`, `'x`, and `'z` literals.
  Value visit(const slang::ast::UnbasedUnsizedIntegerLiteral &expr) {
    return context.materializeSVInt(expr.getValue(), *expr.type, loc);
  }
 
  // Handle integer literals.
  Value visit(const slang::ast::IntegerLiteral &expr) {
    return context.materializeSVInt(expr.getValue(), *expr.type, loc);
  }
 
  // Handle time literals.
  Value visit(const slang::ast::TimeLiteral &expr) {
    // The time literal is expressed in the current time scale. Determine the
    // conversion factor to convert the literal from the current time scale into
    // femtoseconds, and round the scaled value to femtoseconds.
    double scale = getTimeScaleInFemtoseconds(context);
    double value = std::round(expr.getValue() * scale);
    assert(value >= 0.0);
 
    // Check that the value does not exceed what we can represent in the IR.
    // Casting the maximum uint64 value to double changes its value from
    // 18446744073709551615 to 18446744073709551616, which makes the comparison
    // overestimate the largest number we can represent. To avoid this, round
    // the maximum value down to the closest number that only has the front 53
    // bits set. This matches the mantissa of a double, plus the implicit
    // leading 1, ensuring that we can accurately represent the limit.
    static constexpr uint64_t limit =
        (std::numeric_limits<uint64_t>::max() >> 11) << 11;
    if (value > limit) {
      mlir::emitError(loc) << "time value is larger than " << limit << " fs";
      return {};
    }
 
    return moore::ConstantTimeOp::create(builder, loc,
                                         static_cast<uint64_t>(value));
  }
 
  // Handle replications.
  Value visit(const slang::ast::ReplicationExpression &expr) {
    auto type = context.convertType(*expr.type);
    auto value = context.convertRvalueExpression(expr.concat());
    if (!value)
      return {};
    return moore::ReplicateOp::create(builder, loc, type, value);
  }
 
  // Handle set membership operator.
  Value visit(const slang::ast::InsideExpression &expr) {
    auto lhs = context.convertToSimpleBitVector(
        context.convertRvalueExpression(expr.left()));
    if (!lhs)
      return {};
 
    // All conditions for determining whether it is inside.
    SmallVector<Value> conditions;
 
    // Traverse open range list.
    for (const auto *listExpr : expr.rangeList()) {
      auto cond = context.convertInsideCheck(lhs, loc, *listExpr);
      if (!cond)
        return {};
 
      conditions.push_back(cond);
    }
 
    // Calculate the final result by `or` op.
    auto result = conditions.back();
    conditions.pop_back();
    while (!conditions.empty()) {
      result = moore::OrOp::create(builder, loc, conditions.back(), result);
      conditions.pop_back();
    }
    return result;
  }
 
  // Handle conditional operator `?:`.
  Value visit(const slang::ast::ConditionalExpression &expr) {
    auto type = context.convertType(*expr.type);
 
    // Handle condition.
    if (expr.conditions.size() > 1) {
      mlir::emitError(loc)
          << "unsupported conditional expression with more than one condition";
      return {};
    }
    const auto &cond = expr.conditions[0];
    if (cond.pattern) {
      mlir::emitError(loc) << "unsupported conditional expression with pattern";
      return {};
    }
    auto value =
        context.convertToBool(context.convertRvalueExpression(*cond.expr));
    if (!value)
      return {};
    auto conditionalOp =
        moore::ConditionalOp::create(builder, loc, type, value);
 
    // Create blocks for true region and false region.
    auto &trueBlock = conditionalOp.getTrueRegion().emplaceBlock();
    auto &falseBlock = conditionalOp.getFalseRegion().emplaceBlock();
 
    OpBuilder::InsertionGuard g(builder);
 
    // Handle left expression.
    builder.setInsertionPointToStart(&trueBlock);
    auto trueValue = context.convertRvalueExpression(expr.left(), type);
    if (!trueValue)
      return {};
    moore::YieldOp::create(builder, loc, trueValue);
 
    // Handle right expression.
    builder.setInsertionPointToStart(&falseBlock);
    auto falseValue = context.convertRvalueExpression(expr.right(), type);
    if (!falseValue)
      return {};
    moore::YieldOp::create(builder, loc, falseValue);
 
    return conditionalOp.getResult();
  }
 
  /// Handle calls.
  Value visit(const slang::ast::CallExpression &expr) {
    // Try to materialize constant values directly.
    auto constant = context.evaluateConstant(expr);
    if (auto value = context.materializeConstant(constant, *expr.type, loc))
      return value;
 
    return std::visit(
        [&](auto &subroutine) { return visitCall(expr, subroutine); },
        expr.subroutine);
  }
 
  /// Get both the actual `this` argument of a method call and the required
  /// class type.
  std::pair<Value, moore::ClassHandleType>
  getMethodReceiverTypeHandle(const slang::ast::CallExpression &expr) {
 
    moore::ClassHandleType handleTy;
    Value thisRef;
 
    // Qualified call: t.m(...), extract from thisClass.
    if (const slang::ast::Expression *recvExpr = expr.thisClass()) {
      thisRef = context.convertRvalueExpression(*recvExpr);
      if (!thisRef)
        return {};
    } else {
      // Unqualified call inside a method body: try using implicit %this.
      thisRef = context.getImplicitThisRef();
      if (!thisRef) {
        mlir::emitError(loc) << "method '" << expr.getSubroutineName()
                             << "' called without an object";
        return {};
      }
    }
    handleTy = cast<moore::ClassHandleType>(thisRef.getType());
    return {thisRef, handleTy};
  }
 
  /// Build a method call including implicit this argument.
  mlir::CallOpInterface
  buildMethodCall(const slang::ast::SubroutineSymbol *subroutine,
                  FunctionLowering *lowering,
                  moore::ClassHandleType actualHandleTy, Value actualThisRef,
                  SmallVector<Value> &arguments,
                  SmallVector<Type> &resultTypes) {
 
    // Get the expected receiver type from the lowered method
    auto funcTy = cast<FunctionType>(lowering->op.getFunctionType());
    auto expected0 = funcTy.getInput(0);
    auto expectedHdlTy = cast<moore::ClassHandleType>(expected0);
 
    // Upcast the handle as necessary.
    auto implicitThisRef = context.materializeConversion(
        expectedHdlTy, actualThisRef, false, actualThisRef.getLoc());
 
    // Build an argument list where the this reference is the first argument.
    SmallVector<Value> explicitArguments;
    explicitArguments.reserve(arguments.size() + 1);
    explicitArguments.push_back(implicitThisRef);
    explicitArguments.append(arguments.begin(), arguments.end());
 
    // Method call: choose direct vs virtual.
    const bool isVirtual =
        (subroutine->flags & slang::ast::MethodFlags::Virtual) != 0;
 
    if (!isVirtual) {
      auto calleeSym = lowering->op.getNameAttr().getValue();
      if (isa<moore::CoroutineOp>(lowering->op.getOperation()))
        return moore::CallCoroutineOp::create(builder, loc, resultTypes,
                                              calleeSym, explicitArguments);
      return mlir::func::CallOp::create(builder, loc, resultTypes, calleeSym,
                                        explicitArguments);
    }
 
    auto funcName = subroutine->name;
    auto method = moore::VTableLoadMethodOp::create(
        builder, loc, funcTy, actualThisRef,
        SymbolRefAttr::get(context.getContext(), funcName));
    return mlir::func::CallIndirectOp::create(builder, loc, method,
                                              explicitArguments);
  }
 
  /// Handle subroutine calls.
  Value visitCall(const slang::ast::CallExpression &expr,
                  const slang::ast::SubroutineSymbol *subroutine) {
 
    const bool isMethod = (subroutine->thisVar != nullptr);
 
    auto *lowering = context.declareFunction(*subroutine);
    if (!lowering)
      return {};
 
    if (isa<moore::DPIFuncOp>(lowering->op.getOperation())) {
      SmallVector<Value> operands;
      SmallVector<Value> resultTargets;
 
      for (auto [callArg, declArg] :
           llvm::zip(expr.arguments(), subroutine->getArguments())) {
        auto *actual = callArg;
        if (const auto *assign =
                actual->as_if<slang::ast::AssignmentExpression>())
          actual = &assign->left();
 
        auto argType = context.convertType(declArg->getType());
        if (!argType)
          return {};
 
        switch (declArg->direction) {
        case slang::ast::ArgumentDirection::In: {
          auto value = context.convertRvalueExpression(*actual, argType);
          if (!value)
            return {};
          operands.push_back(value);
          break;
        }
        case slang::ast::ArgumentDirection::Out: {
          auto lvalue = context.convertLvalueExpression(*actual);
          if (!lvalue)
            return {};
          resultTargets.push_back(lvalue);
          break;
        }
        case slang::ast::ArgumentDirection::InOut:
        case slang::ast::ArgumentDirection::Ref: {
          auto lvalue = context.convertLvalueExpression(*actual);
          if (!lvalue)
            return {};
          auto value = context.convertRvalueExpression(*actual, argType);
          if (!value)
            return {};
          operands.push_back(value);
          resultTargets.push_back(lvalue);
          break;
        }
        }
      }
 
      SmallVector<Type> resultTypes(
          cast<FunctionType>(lowering->op.getFunctionType()).getResults());
      auto callOp = moore::FuncDPICallOp::create(
          builder, loc, resultTypes,
          SymbolRefAttr::get(lowering->op.getNameAttr()), operands);
 
      unsigned resultIndex = 0;
      unsigned targetIndex = 0;
      for (const auto *declArg : subroutine->getArguments()) {
        auto argType = context.convertType(declArg->getType());
        if (!argType)
          return {};
 
        switch (declArg->direction) {
        case slang::ast::ArgumentDirection::Out:
        case slang::ast::ArgumentDirection::InOut:
        case slang::ast::ArgumentDirection::Ref: {
          auto lvalue = resultTargets[targetIndex++];
          auto refTy = dyn_cast<moore::RefType>(lvalue.getType());
          if (!refTy) {
            lowering->op->emitError(
                "expected DPI output target to be moore::RefType");
            return {};
          }
          auto converted = context.materializeConversion(
              refTy.getNestedType(), callOp->getResult(resultIndex++),
              declArg->getType().isSigned(), loc);
          if (!converted)
            return {};
          moore::BlockingAssignOp::create(builder, loc, lvalue, converted);
          break;
        }
        default:
          break;
        }
      }
 
      if (!subroutine->getReturnType().isVoid())
        return callOp->getResult(resultIndex);
 
      return mlir::UnrealizedConversionCastOp::create(
                 builder, loc, moore::VoidType::get(context.getContext()),
                 ValueRange{})
          .getResult(0);
    }
 
    // Convert the call arguments. Input arguments are converted to an rvalue.
    // All other arguments are converted to lvalues and passed into the
    // function by reference. If a call argument's type doesn't match the
    // declared argument's type, `output` and `inout` arguments are instead
    // routed through a local temporary of the declared type, converting on
    // copy-in and copy-out. See IEEE 1800-2017 §13.5 and §4.9.7.
    struct Writeback {
      Value temp;
      Value lvalue;
      bool declIsSigned;
    };
    SmallVector<Writeback> writebacks;
    SmallVector<Value> arguments;
 
    for (auto [callArg, declArg] :
         llvm::zip(expr.arguments(), subroutine->getArguments())) {
 
      // Unpack the `<expr> = EmptyArgument` pattern emitted by Slang for output
      // and inout arguments.
      auto *expr = callArg;
      if (const auto *assign = expr->as_if<slang::ast::AssignmentExpression>())
        expr = &assign->left();
 
      Value value;
      auto type = context.convertType(declArg->getType());
      if (declArg->direction == slang::ast::ArgumentDirection::In) {
        value = context.convertRvalueExpression(*expr, type);
      } else {
        Value lvalue = context.convertLvalueExpression(*expr);
        if (!lvalue)
          return {};
        auto unpackedType = dyn_cast<moore::UnpackedType>(type);
        if (!unpackedType)
          return {};
        auto refType = moore::RefType::get(unpackedType);
 
        if (declArg->direction == slang::ast::ArgumentDirection::Ref) {
          // Since we can't really cast ref types, reject any ref argument
          // whose call argument doesn't match the declared argument's type
          // exactly.
          if (lvalue.getType() != refType) {
            mlir::emitError(loc)
                << "ref argument `" << declArg->name << "` expects " << refType
                << " but call provides " << lvalue.getType();
            return {};
          }
          value = lvalue;
        } else if (lvalue.getType() == refType) {
          value = lvalue;
        } else {
          Value copyIn;
          if (declArg->direction == slang::ast::ArgumentDirection::InOut) {
            copyIn = moore::ReadOp::create(builder, loc, lvalue);
            copyIn = context.materializeConversion(unpackedType, copyIn,
                                                   expr->type->isSigned(), loc);
            if (!copyIn)
              return {};
          }
          value = moore::VariableOp::create(builder, loc, refType, StringAttr{},
                                            copyIn);
          writebacks.push_back({value, lvalue, declArg->getType().isSigned()});
        }
      }
      if (!value)
        return {};
      arguments.push_back(value);
    }
 
    // Pass captured variables as extra arguments. Each captured AST symbol is
    // resolved to an MLIR value through the scoped symbol table, which
    // naturally handles transitive captures (the caller’s own capture block
    // argument will be found for variables captured from an outer scope).
    for (auto *sym : lowering->capturedSymbols) {
      Value val = context.valueSymbols.lookup(sym);
      if (!val) {
        mlir::emitError(loc) << "failed to resolve captured variable `"
                             << sym->name << "` at call site";
        return {};
      }
      arguments.push_back(val);
    }
 
    // Determine result types from the declared/converted func op.
    SmallVector<Type> resultTypes(
        cast<FunctionType>(lowering->op.getFunctionType()).getResults().begin(),
        cast<FunctionType>(lowering->op.getFunctionType()).getResults().end());
 
    mlir::CallOpInterface callOp;
    if (isMethod) {
      // Class functions -> build func.call / func.indirect_call with implicit
      // this argument
      auto [thisRef, tyHandle] = getMethodReceiverTypeHandle(expr);
      callOp = buildMethodCall(subroutine, lowering, tyHandle, thisRef,
                               arguments, resultTypes);
    } else if (isa<moore::CoroutineOp>(lowering->op.getOperation())) {
      // Free task -> moore.call_coroutine
      auto coroutine = cast<moore::CoroutineOp>(lowering->op.getOperation());
      callOp =
          moore::CallCoroutineOp::create(builder, loc, coroutine, arguments);
    } else {
      // Free function -> func.call
      auto funcOp = cast<mlir::func::FuncOp>(lowering->op.getOperation());
      callOp = mlir::func::CallOp::create(builder, loc, funcOp, arguments);
    }
 
    // Copy output/inout arguments that were routed through a temporary back
    // to their call argument now that the call has returned.
    for (auto &writeback : writebacks) {
      Value rvalue = moore::ReadOp::create(builder, loc, writeback.temp);
      auto dstType =
          cast<moore::RefType>(writeback.lvalue.getType()).getNestedType();
      rvalue = context.materializeConversion(dstType, rvalue,
                                             writeback.declIsSigned, loc);
      if (!rvalue)
        return {};
      moore::BlockingAssignOp::create(builder, loc, writeback.lvalue, rvalue);
    }
 
    auto result = resultTypes.size() > 0 ? callOp->getOpResult(0) : Value{};
    // For calls to void functions we need to have a value to return from this
    // function. Create a dummy `unrealized_conversion_cast`, which will get
    // deleted again later on.
    if (resultTypes.size() == 0)
      return mlir::UnrealizedConversionCastOp::create(
                 builder, loc, moore::VoidType::get(context.getContext()),
                 ValueRange{})
          .getResult(0);
 
    return result;
  }
 
  /// Handle system calls.
  Value visitCall(const slang::ast::CallExpression &expr,
                  const slang::ast::CallExpression::SystemCallInfo &info) {
    using ksn = slang::parsing::KnownSystemName;
    const auto &subroutine = *info.subroutine;
    auto nameId = subroutine.knownNameId;
 
    // $rose, $fell, $stable, $changed, $past, and $sampled are only valid in
    // the contexts with clocks. Those are treated in AssertionExpr.
    switch (nameId) {
    case ksn::Rose:
    case ksn::Fell:
    case ksn::Stable:
    case ksn::Changed:
    case ksn::Past:
    case ksn::Sampled:
      return context.convertSampledValueCallExpression(expr, info, loc);
    default:
      break;
    }
 
    auto args = expr.arguments();
 
    // $sformatf() and $sformat look like system tasks, but we handle string
    // formatting differently from expression evaluation, so handle them
    // separately.
    // According to IEEE 1800-2023 Section 21.3.3 "Formatting data to a
    // string" $sformatf works just like the string formatting but returns
    // a StringType.
    if (nameId == ksn::SFormatF) {
      // Create the FormatString
      auto fmtValue = context.convertFormatString(
          expr.arguments(), loc, moore::IntFormat::Decimal, false);
      if (failed(fmtValue))
        return {};
      return fmtValue.value();
    }
 
    // Convert the system call using unified dispatch
    auto result = context.convertSystemCall(subroutine, loc, args);
    if (!result)
      return {};
 
    auto ty = context.convertType(*expr.type);
    // Bit vector builtins ($countones, $isunknown, $onehot, $onehot0) return
    // inherently unsigned results that must be zero-extended, even though
    // Slang's declared return type may be signed int.
    bool isSigned = expr.type->isSigned();
    if (nameId == ksn::CountOnes || nameId == ksn::IsUnknown ||
        nameId == ksn::OneHot || nameId == ksn::OneHot0)
      isSigned = false;
    return context.materializeConversion(ty, result, isSigned, loc);
  }
 
  /// Handle string literals.
  Value visit(const slang::ast::StringLiteral &expr) {
    auto type = context.convertType(*expr.type);
    return moore::ConstantStringOp::create(builder, loc, type, expr.getValue());
  }
 
  /// Handle real literals.
  Value visit(const slang::ast::RealLiteral &expr) {
    auto fTy = mlir::Float64Type::get(context.getContext());
    auto attr = mlir::FloatAttr::get(fTy, expr.getValue());
    return moore::ConstantRealOp::create(builder, loc, attr).getResult();
  }
 
  /// Helper function to convert RValues at creation of a new Struct, Array or
  /// Int.
  FailureOr<SmallVector<Value>>
  convertElements(const slang::ast::AssignmentPatternExpressionBase &expr,
                  std::variant<Type, ArrayRef<Type>> expectedTypes,
                  unsigned replCount) {
    const auto &elts = expr.elements();
    const size_t elementCount = elts.size();
 
    // Inspect the variant.
    const bool hasBroadcast =
        std::holds_alternative<Type>(expectedTypes) &&
        static_cast<bool>(std::get<Type>(expectedTypes)); // non-null Type
 
    const bool hasPerElem =
        std::holds_alternative<ArrayRef<Type>>(expectedTypes) &&
        !std::get<ArrayRef<Type>>(expectedTypes).empty();
 
    // If per-element types are provided, enforce arity.
    if (hasPerElem) {
      auto types = std::get<ArrayRef<Type>>(expectedTypes);
      if (types.size() != elementCount) {
        mlir::emitError(loc)
            << "assignment pattern arity mismatch: expected " << types.size()
            << " elements, got " << elementCount;
        return failure();
      }
    }
 
    SmallVector<Value> converted;
    converted.reserve(elementCount * std::max(1u, replCount));
 
    // Convert each element heuristically, no type is expected
    if (!hasBroadcast && !hasPerElem) {
      // No expected type info.
      for (const auto *elementExpr : elts) {
        Value v = context.convertRvalueExpression(*elementExpr);
        if (!v)
          return failure();
        converted.push_back(v);
      }
    } else if (hasBroadcast) {
      // Same expected type for all elements.
      Type want = std::get<Type>(expectedTypes);
      for (const auto *elementExpr : elts) {
        Value v = want ? context.convertRvalueExpression(*elementExpr, want)
                       : context.convertRvalueExpression(*elementExpr);
        if (!v)
          return failure();
        converted.push_back(v);
      }
    } else { // hasPerElem, individual type is expected for each element
      auto types = std::get<ArrayRef<Type>>(expectedTypes);
      for (size_t i = 0; i < elementCount; ++i) {
        Type want = types[i];
        const auto *elementExpr = elts[i];
        Value v = want ? context.convertRvalueExpression(*elementExpr, want)
                       : context.convertRvalueExpression(*elementExpr);
        if (!v)
          return failure();
        converted.push_back(v);
      }
    }
 
    for (unsigned i = 1; i < replCount; ++i)
      converted.append(converted.begin(), converted.begin() + elementCount);
 
    return converted;
  }
 
  /// Handle assignment patterns.
  Value visitAssignmentPattern(
      const slang::ast::AssignmentPatternExpressionBase &expr,
      unsigned replCount = 1) {
    auto type = context.convertType(*expr.type);
    const auto &elts = expr.elements();
 
    // Handle integers.
    if (auto intType = dyn_cast<moore::IntType>(type)) {
      auto elements = convertElements(expr, {}, replCount);
 
      if (failed(elements))
        return {};
 
      assert(intType.getWidth() == elements->size());
      ensureDescendingOrder(*elements, *expr.type);
      return moore::ConcatOp::create(builder, loc, intType, *elements);
    }
 
    // Handle packed structs.
    if (auto structType = dyn_cast<moore::StructType>(type)) {
      SmallVector<Type> expectedTy;
      expectedTy.reserve(structType.getMembers().size());
      for (auto member : structType.getMembers())
        expectedTy.push_back(member.type);
 
      FailureOr<SmallVector<Value>> elements;
      if (expectedTy.size() == elts.size())
        elements = convertElements(expr, expectedTy, replCount);
      else
        elements = convertElements(expr, {}, replCount);
 
      if (failed(elements))
        return {};
 
      assert(structType.getMembers().size() == elements->size());
      return moore::StructCreateOp::create(builder, loc, structType, *elements);
    }
 
    // Handle unpacked structs.
    if (auto structType = dyn_cast<moore::UnpackedStructType>(type)) {
      SmallVector<Type> expectedTy;
      expectedTy.reserve(structType.getMembers().size());
      for (auto member : structType.getMembers())
        expectedTy.push_back(member.type);
 
      FailureOr<SmallVector<Value>> elements;
      if (expectedTy.size() == elts.size())
        elements = convertElements(expr, expectedTy, replCount);
      else
        elements = convertElements(expr, {}, replCount);
 
      if (failed(elements))
        return {};
 
      assert(structType.getMembers().size() == elements->size());
 
      return moore::StructCreateOp::create(builder, loc, structType, *elements);
    }
 
    // Handle packed arrays.
    if (auto arrayType = dyn_cast<moore::ArrayType>(type)) {
      auto elements =
          convertElements(expr, arrayType.getElementType(), replCount);
 
      if (failed(elements))
        return {};
 
      assert(arrayType.getSize() == elements->size());
      ensureDescendingOrder(*elements, *expr.type);
      return moore::ArrayCreateOp::create(builder, loc, arrayType, *elements);
    }
 
    // Handle unpacked arrays.
    if (auto arrayType = dyn_cast<moore::UnpackedArrayType>(type)) {
      auto elements =
          convertElements(expr, arrayType.getElementType(), replCount);
 
      if (failed(elements))
        return {};
 
      assert(arrayType.getSize() == elements->size());
      return moore::ArrayCreateOp::create(builder, loc, arrayType, *elements);
    }
 
    // Handle open/dynamic unpacked arrays.
    if (auto openType = dyn_cast<moore::OpenUnpackedArrayType>(type)) {
      auto elements =
          convertElements(expr, openType.getElementType(), replCount);
 
      if (failed(elements))
        return {};
 
      auto arrayType = moore::UnpackedArrayType::get(
          context.getContext(), elements->size(), openType.getElementType());
      return moore::ArrayCreateOp::create(builder, loc, arrayType, *elements);
    }
 
    mlir::emitError(loc) << "unsupported assignment pattern with type " << type;
    return {};
  }
 
  Value visit(const slang::ast::SimpleAssignmentPatternExpression &expr) {
    return visitAssignmentPattern(expr);
  }
 
  Value visit(const slang::ast::StructuredAssignmentPatternExpression &expr) {
    return visitAssignmentPattern(expr);
  }
 
  Value visit(const slang::ast::ReplicatedAssignmentPatternExpression &expr) {
    auto count =
        context.evaluateConstant(expr.count()).integer().as<unsigned>();
    assert(count && "Slang guarantees constant non-zero replication count");
    return visitAssignmentPattern(expr, *count);
  }
 
  Value visit(const slang::ast::StreamingConcatenationExpression &expr) {
    SmallVector<Value> operands;
    for (auto stream : expr.streams()) {
      auto operandLoc = context.convertLocation(stream.operand->sourceRange);
      if (!stream.constantWithWidth.has_value() && stream.withExpr) {
        mlir::emitError(operandLoc)
            << "Moore only support streaming "
               "concatenation with fixed size 'with expression'";
        return {};
      }
      Value value;
      if (stream.constantWithWidth.has_value()) {
        value = context.convertRvalueExpression(*stream.withExpr);
        auto type = cast<moore::UnpackedType>(value.getType());
        auto intType = moore::IntType::get(
            context.getContext(), type.getBitSize().value(), type.getDomain());
        // Do not care if it's signed, because we will not do expansion.
        value = context.materializeConversion(intType, value, false, loc);
      } else {
        value = context.convertRvalueExpression(*stream.operand);
      }
 
      value = context.convertToSimpleBitVector(value);
      if (!value)
        return {};
      operands.push_back(value);
    }
    Value value;
 
    if (operands.size() == 1) {
      // There must be at least one element, otherwise slang will report an
      // error.
      value = operands.front();
    } else {
      value = moore::ConcatOp::create(builder, loc, operands).getResult();
    }
 
    if (expr.getSliceSize() == 0) {
      return value;
    }
 
    auto type = cast<moore::IntType>(value.getType());
    SmallVector<Value> slicedOperands;
    auto iterMax = type.getWidth() / expr.getSliceSize();
    auto remainSize = type.getWidth() % expr.getSliceSize();
 
    for (size_t i = 0; i < iterMax; i++) {
      auto extractResultType = moore::IntType::get(
          context.getContext(), expr.getSliceSize(), type.getDomain());
 
      auto extracted = moore::ExtractOp::create(builder, loc, extractResultType,
                                                value, i * expr.getSliceSize());
      slicedOperands.push_back(extracted);
    }
    // Handle other wire
    if (remainSize) {
      auto extractResultType = moore::IntType::get(
          context.getContext(), remainSize, type.getDomain());
 
      auto extracted =
          moore::ExtractOp::create(builder, loc, extractResultType, value,
                                   iterMax * expr.getSliceSize());
      slicedOperands.push_back(extracted);
    }
 
    return moore::ConcatOp::create(builder, loc, slicedOperands);
  }
 
  Value visit(const slang::ast::AssertionInstanceExpression &expr) {
    return context.convertAssertionExpression(expr.body, loc);
  }
 
  Value visit(const slang::ast::UnboundedLiteral &expr) {
    assert(context.getIndexedQueue() &&
           "slang checks $ only used within queue index expression");
 
    // Compute queue size and subtract one to get the last element
    auto queueSize =
        moore::QueueSizeBIOp::create(builder, loc, context.getIndexedQueue());
    auto one = moore::ConstantOp::create(builder, loc, queueSize.getType(), 1);
    auto lastElement = moore::SubOp::create(builder, loc, queueSize, one);
 
    return lastElement;
  }
 
  // A new class expression can stand for one of two things:
  // 1) A call to the `new` method (ctor) of a class made outside the scope of
  // the class
  // 2) A call to the `super.new` method, i.e. the constructor of the base
  // class, within the scope of a class, more specifically, within the new
  // method override of a class.
  // In the first case we should emit an allocation and a call to the ctor if it
  // exists (it's optional in System Verilog), in the second case we should emit
  // a call to the parent's ctor (System Verilog only has single inheritance, so
  // super is always unambiguous), but no allocation, as the child class' new
  // invocation already allocated space for both its own and its parent's
  // properties.
  Value visit(const slang::ast::NewClassExpression &expr) {
    auto type = context.convertType(*expr.type);
    auto classTy = dyn_cast<moore::ClassHandleType>(type);
    Value newObj;
 
    // We are calling new from within a new function, and it's pointing to
    // super. Check the implicit this ref to figure out the super class type.
    // Do not allocate a new object.
    if (!classTy && expr.isSuperClass) {
      newObj = context.getImplicitThisRef();
      if (!newObj || !newObj.getType() ||
          !isa<moore::ClassHandleType>(newObj.getType())) {
        mlir::emitError(loc) << "implicit this ref was not set while "
                                "converting new class function";
        return {};
      }
      auto thisType = cast<moore::ClassHandleType>(newObj.getType());
      auto classDecl =
          cast<moore::ClassDeclOp>(*context.symbolTable.lookupNearestSymbolFrom(
              context.intoModuleOp, thisType.getClassSym()));
      auto baseClassSym = classDecl.getBase();
      classTy = circt::moore::ClassHandleType::get(context.getContext(),
                                                   baseClassSym.value());
    } else {
      // We are calling from outside a class; allocate space for the object.
      newObj = moore::ClassNewOp::create(builder, loc, classTy, {});
    }
 
    const auto *constructor = expr.constructorCall();
    // If there's no ctor, we are done.
    if (!constructor)
      return newObj;
 
    if (const auto *callConstructor =
            constructor->as_if<slang::ast::CallExpression>())
      if (const auto *subroutine =
              std::get_if<const slang::ast::SubroutineSymbol *>(
                  &callConstructor->subroutine)) {
        if (!(*subroutine)->thisVar) {
          mlir::emitError(loc)
              << "unsupported constructor call without `this` argument";
          return {};
        }
        // Pass the newObj as the implicit this argument of the ctor.
        llvm::SaveAndRestore saveThis(context.currentThisRef, newObj);
        if (!visitCall(*callConstructor, *subroutine))
          return {};
        return newObj;
      }
    return {};
  }
 
  /// Emit an error for all other expressions.
  template <typename T>
  Value visit(T &&node) {
    mlir::emitError(loc, "unsupported expression: ")
        << slang::ast::toString(node.kind);
    return {};
  }
 
  Value visitInvalid(const slang::ast::Expression &expr) {
    mlir::emitError(loc, "invalid expression");
    return {};
  }
};
} // namespace
 
//===----------------------------------------------------------------------===//
// Lvalue Conversion
//===----------------------------------------------------------------------===//
 
namespace {
struct LvalueExprVisitor : public ExprVisitor {
  LvalueExprVisitor(Context &context, Location loc)
      : ExprVisitor(context, loc, /*isLvalue=*/true) {}
  using ExprVisitor::visit;
 
  // Handle named values, such as references to declared variables.
  Value visit(const slang::ast::NamedValueExpression &expr) {
    // Handle local variables.
    if (auto value = context.valueSymbols.lookup(&expr.symbol))
      return value;
 
    // Handle global variables.
    if (auto globalOp = context.globalVariables.lookup(&expr.symbol))
      return moore::GetGlobalVariableOp::create(builder, loc, globalOp);
 
    if (auto *const property =
            expr.symbol.as_if<slang::ast::ClassPropertySymbol>()) {
      return visitClassProperty(context, *property);
    }
 
    if (auto access = context.virtualIfaceMembers.lookup(&expr.symbol);
        access.base) {
      auto type = context.convertType(*expr.type);
      if (!type)
        return {};
      auto memberType = dyn_cast<moore::UnpackedType>(type);
      if (!memberType) {
        mlir::emitError(loc)
            << "unsupported virtual interface member type: " << type;
        return {};
      }
 
      Value base = materializeSymbolRvalue(*access.base);
      if (!base) {
        auto d = mlir::emitError(loc, "unknown name `")
                 << access.base->name << "`";
        d.attachNote(context.convertLocation(access.base->location))
            << "no rvalue generated for virtual interface base";
        return {};
      }
 
      auto fieldName = access.fieldName
                           ? access.fieldName
                           : builder.getStringAttr(expr.symbol.name);
      auto memberRefType = moore::RefType::get(memberType);
      return moore::StructExtractOp::create(builder, loc, memberRefType,
                                            fieldName, base);
    }
 
    auto d = mlir::emitError(loc, "unknown name `") << expr.symbol.name << "`";
    d.attachNote(context.convertLocation(expr.symbol.location))
        << "no lvalue generated for " << slang::ast::toString(expr.symbol.kind);
    return {};
  }
 
  // Handle hierarchical values, such as `Top.sub.var = x`.
  Value visit(const slang::ast::HierarchicalValueExpression &expr) {
    // Canonicalize self-references (e.g., SubD.w inside SubD) to local
    // variable lookups (same rationale as rvalue visitor).
    if (!expr.ref.path.empty()) {
      if (auto *inst = expr.ref.path.front()
                           .symbol->as_if<slang::ast::InstanceSymbol>()) {
        auto *symbolBody =
            expr.symbol.getParentScope()->getContainingInstance();
        if (&inst->body == symbolBody ||
            (symbolBody && inst->body.getDeclaringDefinition() ==
                               symbolBody->getDeclaringDefinition())) {
          if (auto value = context.valueSymbols.lookup(&expr.symbol))
            return value;
        }
      }
    }
 
    // Same capture priority as the rvalue visitor.
    if (auto value = context.resolveCapturedValue(expr.symbol))
      return value;
 
    // For cross-instance hierarchical references, use the instance-aware
    // hierValueSymbols lookup (same priority and rationale as rvalue
    // visitor).
    if (auto key = context.buildHierValueKey(expr)) {
      if (auto it = context.hierValueSymbols.find(*key);
          it != context.hierValueSymbols.end())
        return it->second;
    }
 
    // Fall back to scoped symbol table (same-scope lookups, self-refs).
    if (auto value = context.valueSymbols.lookup(&expr.symbol))
      return value;
 
    if (auto value = lookupExpandedInterfaceMember(context, expr))
      return value;
 
    // Handle global variables.
    if (auto globalOp = context.globalVariables.lookup(&expr.symbol))
      return moore::GetGlobalVariableOp::create(builder, loc, globalOp);
 
    // Emit an error for those hierarchical values not recorded in the
    // `valueSymbols`.
    auto d = mlir::emitError(loc, "unknown hierarchical name `")
             << expr.symbol.name << "`";
    d.attachNote(context.convertLocation(expr.symbol.location))
        << "no lvalue generated for " << slang::ast::toString(expr.symbol.kind);
    return {};
  }
 
  Value visit(const slang::ast::StreamingConcatenationExpression &expr) {
    SmallVector<Value> operands;
    for (auto stream : expr.streams()) {
      auto operandLoc = context.convertLocation(stream.operand->sourceRange);
      if (!stream.constantWithWidth.has_value() && stream.withExpr) {
        mlir::emitError(operandLoc)
            << "Moore only support streaming "
               "concatenation with fixed size 'with expression'";
        return {};
      }
      Value value;
      if (stream.constantWithWidth.has_value()) {
        value = context.convertLvalueExpression(*stream.withExpr);
        auto type = cast<moore::UnpackedType>(
            cast<moore::RefType>(value.getType()).getNestedType());
        auto intType = moore::RefType::get(moore::IntType::get(
            context.getContext(), type.getBitSize().value(), type.getDomain()));
        // Do not care if it's signed, because we will not do expansion.
        value = context.materializeConversion(intType, value, false, loc);
      } else {
        value = context.convertLvalueExpression(*stream.operand);
      }
 
      if (!value)
        return {};
      operands.push_back(value);
    }
    Value value;
    if (operands.size() == 1) {
      // There must be at least one element, otherwise slang will report an
      // error.
      value = operands.front();
    } else {
      value = moore::ConcatRefOp::create(builder, loc, operands).getResult();
    }
 
    if (expr.getSliceSize() == 0) {
      return value;
    }
 
    auto type = cast<moore::IntType>(
        cast<moore::RefType>(value.getType()).getNestedType());
    SmallVector<Value> slicedOperands;
    auto widthSum = type.getWidth();
    auto domain = type.getDomain();
    auto iterMax = widthSum / expr.getSliceSize();
    auto remainSize = widthSum % expr.getSliceSize();
 
    for (size_t i = 0; i < iterMax; i++) {
      auto extractResultType = moore::RefType::get(moore::IntType::get(
          context.getContext(), expr.getSliceSize(), domain));
 
      auto extracted = moore::ExtractRefOp::create(
          builder, loc, extractResultType, value, i * expr.getSliceSize());
      slicedOperands.push_back(extracted);
    }
    // Handle other wire
    if (remainSize) {
      auto extractResultType = moore::RefType::get(
          moore::IntType::get(context.getContext(), remainSize, domain));
 
      auto extracted =
          moore::ExtractRefOp::create(builder, loc, extractResultType, value,
                                      iterMax * expr.getSliceSize());
      slicedOperands.push_back(extracted);
    }
 
    return moore::ConcatRefOp::create(builder, loc, slicedOperands);
  }
 
  /// Emit an error for all other expressions.
  template <typename T>
  Value visit(T &&node) {
    return context.convertRvalueExpression(node);
  }
 
  Value visitInvalid(const slang::ast::Expression &expr) {
    mlir::emitError(loc, "invalid expression");
    return {};
  }
};
} // namespace
 
//===----------------------------------------------------------------------===//
// Hierarchical Name Helpers
//===----------------------------------------------------------------------===//
 
Value Context::resolveCapturedValue(const slang::ast::ValueSymbol &sym) {
  if (!currentFunctionLowering)
    return {};
  if (!llvm::is_contained(currentFunctionLowering->capturedSymbols, &sym))
    return {};
  return valueSymbols.lookup(&sym);
}
 
std::optional<std::pair<const slang::ast::InstanceSymbol *, mlir::StringAttr>>
Context::buildHierValueKey(
    const slang::ast::HierarchicalValueExpression &expr) {
  if (expr.ref.path.empty())
    return std::nullopt;
 
  const slang::ast::InstanceSymbol *firstInst = nullptr;
  SmallVector<StringRef, 4> names;
  for (auto &elem : expr.ref.path) {
    if (auto *inst = elem.symbol->as_if<slang::ast::InstanceSymbol>()) {
      if (!firstInst) {
        firstInst = inst;
      } else {
        names.push_back(inst->name);
      }
    }
  }
  names.push_back(expr.symbol.name);
  std::string hierName = llvm::join(names, ".");
 
  if (!firstInst)
    return std::nullopt;
  return std::make_pair(firstInst, builder.getStringAttr(hierName));
}
 
//===----------------------------------------------------------------------===//
// Entry Points
//===----------------------------------------------------------------------===//
 
Value Context::convertRvalueExpression(const slang::ast::Expression &expr,
                                       Type requiredType) {
  auto loc = convertLocation(expr.sourceRange);
  auto value = expr.visit(RvalueExprVisitor(*this, loc));
  if (value && requiredType)
    value =
        materializeConversion(requiredType, value, expr.type->isSigned(), loc);
  return value;
}
 
Value Context::convertLvalueExpression(const slang::ast::Expression &expr) {
  auto loc = convertLocation(expr.sourceRange);
  return expr.visit(LvalueExprVisitor(*this, loc));
}
// NOLINTEND(misc-no-recursion)
 
/// Helper function to convert a value to its "truthy" boolean value.
Value Context::convertToBool(Value value) {
  if (!value)
    return {};
  if (auto type = dyn_cast_or_null<moore::IntType>(value.getType()))
    if (type.getBitSize() == 1)
      return value;
  if (auto type = dyn_cast_or_null<moore::UnpackedType>(value.getType()))
    return moore::BoolCastOp::create(builder, value.getLoc(), value);
  mlir::emitError(value.getLoc(), "expression of type ")
      << value.getType() << " cannot be cast to a boolean";
  return {};
}
 
/// Materialize a Slang real literal as a constant op.
Value Context::materializeSVReal(const slang::ConstantValue &svreal,
                                 const slang::ast::Type &astType,
                                 Location loc) {
  const auto *floatType = astType.as_if<slang::ast::FloatingType>();
  assert(floatType);
 
  FloatAttr attr;
  if (svreal.isShortReal() &&
      floatType->floatKind == slang::ast::FloatingType::ShortReal) {
    attr = FloatAttr::get(builder.getF32Type(), svreal.shortReal().v);
  } else if (svreal.isReal() &&
             floatType->floatKind == slang::ast::FloatingType::Real) {
    attr = FloatAttr::get(builder.getF64Type(), svreal.real().v);
  } else {
    mlir::emitError(loc) << "invalid real constant";
    return {};
  }
 
  return moore::ConstantRealOp::create(builder, loc, attr);
}
 
/// 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 {};
  const std::string &str = stringLiteral.str();
  auto intTy = moore::IntType::getInt(getContext(),
                                      static_cast<unsigned>(str.size() * 8));
  auto immInt =
      moore::ConstantStringOp::create(builder, loc, intTy, str).getResult();
  return moore::IntToStringOp::create(builder, loc, immInt).getResult();
}
 
/// Materialize a Slang integer literal as a constant op.
Value Context::materializeSVInt(const slang::SVInt &svint,
                                const slang::ast::Type &astType, Location loc) {
  auto type = convertType(astType);
  if (!type)
    return {};
 
  bool typeIsFourValued = false;
  if (auto unpackedType = dyn_cast<moore::UnpackedType>(type))
    typeIsFourValued = unpackedType.getDomain() == moore::Domain::FourValued;
 
  auto fvint = convertSVIntToFVInt(svint);
  auto intType = moore::IntType::get(getContext(), fvint.getBitWidth(),
                                     fvint.hasUnknown() || typeIsFourValued
                                         ? moore::Domain::FourValued
                                         : moore::Domain::TwoValued);
  auto result = moore::ConstantOp::create(builder, loc, intType, fvint);
  return materializeConversion(type, result, astType.isSigned(), loc);
}
 
Value Context::materializeFixedSizeUnpackedArrayType(
    const slang::ConstantValue &constant,
    const slang::ast::FixedSizeUnpackedArrayType &astType, Location loc) {
 
  auto type = convertType(astType);
  if (!type)
    return {};
 
  // Handle string array constants.
  if (astType.elementType.isString()) {
    auto arrayType = dyn_cast<moore::UnpackedArrayType>(type);
    if (!arrayType)
      return {};
 
    SmallVector<Value> elemVals;
    for (const auto &elem : constant.elements()) {
      if (!elem.isString())
        return {};
      auto value = materializeString(elem, astType.elementType, loc);
      if (!value)
        return {};
      elemVals.push_back(value);
    }
    if (elemVals.size() != arrayType.getSize())
      return {};
    return moore::ArrayCreateOp::create(builder, loc, arrayType, elemVals);
  }
 
  // Check whether underlying type is an integer, if so, get bit width
  unsigned bitWidth;
  if (astType.elementType.isIntegral())
    bitWidth = astType.elementType.getBitWidth();
  else
    return {};
 
  bool typeIsFourValued = false;
 
  // Check whether the underlying type is four-valued
  if (auto unpackedType = dyn_cast<moore::UnpackedType>(type))
    typeIsFourValued = unpackedType.getDomain() == moore::Domain::FourValued;
  else
    return {};
 
  auto domain =
      typeIsFourValued ? moore::Domain::FourValued : moore::Domain::TwoValued;
 
  // Construct the integer type this is an unpacked array of; if possible keep
  // it two-valued, unless any entry is four-valued or the underlying type is
  // four-valued
  auto intType = moore::IntType::get(getContext(), bitWidth, domain);
  // Construct the full array type from intType
  auto arrType = moore::UnpackedArrayType::get(
      getContext(), constant.elements().size(), intType);
 
  llvm::SmallVector<mlir::Value> elemVals;
  moore::ConstantOp constOp;
 
  mlir::OpBuilder::InsertionGuard guard(builder);
 
  // Add one ConstantOp for every element in the array
  for (auto elem : constant.elements()) {
    FVInt fvInt = convertSVIntToFVInt(elem.integer());
    constOp = moore::ConstantOp::create(builder, loc, intType, fvInt);
    elemVals.push_back(constOp.getResult());
  }
 
  // Take the result of each ConstantOp and concatenate them into an array (of
  // constant values).
  auto arrayOp = moore::ArrayCreateOp::create(builder, loc, arrType, elemVals);
 
  return arrayOp.getResult();
}
 
Value Context::materializeConstant(const slang::ConstantValue &constant,
                                   const slang::ast::Type &type, Location loc) {
 
  if (auto *arr = type.as_if<slang::ast::FixedSizeUnpackedArrayType>())
    return materializeFixedSizeUnpackedArrayType(constant, *arr, loc);
  if (constant.isInteger())
    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 {};
}
 
slang::ConstantValue
Context::evaluateConstant(const slang::ast::Expression &expr) {
  using slang::ast::EvalFlags;
  slang::ast::EvalContext evalContext(
      slang::ast::ASTContext(compilation.getRoot(),
                             slang::ast::LookupLocation::max),
      EvalFlags::CacheResults | EvalFlags::SpecparamsAllowed);
  return expr.eval(evalContext);
}
 
/// Helper function to convert a value to its "truthy" boolean value and
/// convert it to the given domain.
Value Context::convertToBool(Value value, Domain domain) {
  value = convertToBool(value);
  if (!value)
    return {};
  auto type = moore::IntType::get(getContext(), 1, domain);
  return materializeConversion(type, value, false, value.getLoc());
}
 
Value Context::convertToSimpleBitVector(Value value) {
  if (!value)
    return {};
  if (isa<moore::IntType>(value.getType()))
    return value;
 
  // Some operations in Slang's AST, for example bitwise or `|`, don't cast
  // packed struct/array operands to simple bit vectors but directly operate
  // on the struct/array. Since the corresponding IR ops operate only on
  // simple bit vectors, insert a conversion in this case.
  if (auto packed = dyn_cast<moore::PackedType>(value.getType()))
    if (auto sbvType = packed.getSimpleBitVector())
      return materializeConversion(sbvType, value, false, value.getLoc());
 
  mlir::emitError(value.getLoc()) << "expression of type " << value.getType()
                                  << " cannot be cast to a simple bit vector";
  return {};
}
 
Value Context::materializePackedToSBVConversion(Value value, Location loc,
                                                bool fallible) {
  if (isa<moore::IntType>(value.getType()))
    return value;
 
  auto packedType = cast<moore::PackedType>(value.getType());
  auto intType = packedType.getSimpleBitVector();
  assert(intType);
 
  // If we are converting from a time to an integer, divide the integer by the
  // timescale.
  if (isa<moore::TimeType>(packedType) &&
      moore::isIntType(intType, 64, moore::Domain::FourValued)) {
    value = builder.createOrFold<moore::TimeToLogicOp>(loc, value);
    auto scale = moore::ConstantOp::create(builder, loc, intType,
                                           getTimeScaleInFemtoseconds(*this));
    return builder.createOrFold<moore::DivUOp>(loc, value, scale);
  }
 
  // If this is an aggregate type, make sure that it does not contain any
  // `TimeType` fields. These require special conversion to ensure that the
  // local timescale is in effect.
  if (packedType.containsTimeType()) {
    if (!fallible)
      mlir::emitError(loc) << "unsupported conversion: " << packedType
                           << " cannot be converted to " << intType
                           << "; contains a time type";
    return {};
  }
 
  // Otherwise create a simple `PackedToSBVOp` for the conversion.
  return builder.createOrFold<moore::PackedToSBVOp>(loc, value);
}
 
/// Create the necessary operations to convert from a simple bit vector
/// `IntType` to an equivalent `PackedType`. This will apply special handling to
/// time values, which requires scaling by the local timescale.
static Value materializeSBVToPackedConversion(Context &context,
                                              moore::PackedType packedType,
                                              Value value, Location loc,
                                              bool fallible) {
  if (value.getType() == packedType)
    return value;
 
  auto &builder = context.builder;
  auto intType = cast<moore::IntType>(value.getType());
  assert(intType && intType == packedType.getSimpleBitVector());
 
  // If we are converting from an integer to a time, multiply the integer by the
  // timescale.
  if (isa<moore::TimeType>(packedType) &&
      moore::isIntType(intType, 64, moore::Domain::FourValued)) {
    auto scale = moore::ConstantOp::create(builder, loc, intType,
                                           getTimeScaleInFemtoseconds(context));
    value = builder.createOrFold<moore::MulOp>(loc, value, scale);
    return builder.createOrFold<moore::LogicToTimeOp>(loc, value);
  }
 
  // If this is an aggregate type, make sure that it does not contain any
  // `TimeType` fields. These require special conversion to ensure that the
  // local timescale is in effect.
  if (packedType.containsTimeType()) {
    if (!fallible)
      mlir::emitError(loc) << "unsupported conversion: " << intType
                           << " cannot be converted to " << packedType
                           << "; contains a time type";
    return {};
  }
 
  // Otherwise create a simple `PackedToSBVOp` for the conversion.
  return builder.createOrFold<moore::SBVToPackedOp>(loc, packedType, value);
}
 
/// Check whether the actual handle is a subclass of another handle type
/// and return a properly upcast version if so.
static mlir::Value maybeUpcastHandle(Context &context, mlir::Value actualHandle,
                                     moore::ClassHandleType expectedHandleTy) {
  auto loc = actualHandle.getLoc();
 
  auto actualTy = actualHandle.getType();
  auto actualHandleTy = dyn_cast<moore::ClassHandleType>(actualTy);
  if (!actualHandleTy) {
    mlir::emitError(loc) << "expected a !moore.class<...> value, got "
                         << actualTy;
    return {};
  }
 
  // Fast path: already the expected handle type.
  if (actualHandleTy == expectedHandleTy)
    return actualHandle;
 
  if (!context.isClassDerivedFrom(actualHandleTy, expectedHandleTy)) {
    mlir::emitError(loc)
        << "receiver class " << actualHandleTy.getClassSym()
        << " is not the same as, or derived from, expected base class "
        << expectedHandleTy.getClassSym().getRootReference();
    return {};
  }
 
  // Only implicit upcasting is allowed - down casting should never be implicit.
  auto casted = moore::ClassUpcastOp::create(context.builder, loc,
                                             expectedHandleTy, actualHandle)
                    .getResult();
  return casted;
}
 
Value Context::materializeConversion(Type type, Value value, bool isSigned,
                                     Location loc, bool fallible) {
  // Nothing to do if the types are already equal.
  if (type == value.getType())
    return value;
 
  // A `null` literal has no bit-level representation to convert; materialize
  // a null value of the destination handle type directly instead.
  if (isa<moore::NullType>(value.getType())) {
    if (isa<moore::ChandleType>(type))
      return moore::NullChandleOp::create(builder, loc);
    if (auto classType = dyn_cast<moore::ClassHandleType>(type))
      return moore::NullClassOp::create(builder, loc, classType);
    if (type == moore::IntType::getInt(value.getContext(), 1))
      return moore::ConstantOp::create(builder, loc, cast<moore::IntType>(type),
                                       0);
  }
 
  // Handle packed types which can be converted to a simple bit vector. This
  // allows us to perform resizing and domain casting on that bit vector.
  auto dstPacked = dyn_cast<moore::PackedType>(type);
  auto srcPacked = dyn_cast<moore::PackedType>(value.getType());
  auto dstInt = dstPacked ? dstPacked.getSimpleBitVector() : moore::IntType();
  auto srcInt = srcPacked ? srcPacked.getSimpleBitVector() : moore::IntType();
 
  if (dstInt && srcInt) {
    // Convert the value to a simple bit vector if it isn't one already.
    value = materializePackedToSBVConversion(value, loc, fallible);
    if (!value)
      return {};
 
    // Create truncation or sign/zero extension ops depending on the source and
    // destination width.
    auto resizedType = moore::IntType::get(
        value.getContext(), dstInt.getWidth(), srcPacked.getDomain());
    if (dstInt.getWidth() < srcInt.getWidth()) {
      value = builder.createOrFold<moore::TruncOp>(loc, resizedType, value);
    } else if (dstInt.getWidth() > srcInt.getWidth()) {
      if (isSigned)
        value = builder.createOrFold<moore::SExtOp>(loc, resizedType, value);
      else
        value = builder.createOrFold<moore::ZExtOp>(loc, resizedType, value);
    }
 
    // Convert the domain if needed.
    if (dstInt.getDomain() != srcInt.getDomain()) {
      if (dstInt.getDomain() == moore::Domain::TwoValued)
        value = builder.createOrFold<moore::LogicToIntOp>(loc, value);
      else if (dstInt.getDomain() == moore::Domain::FourValued)
        value = builder.createOrFold<moore::IntToLogicOp>(loc, value);
    }
 
    // Convert the value from a simple bit vector back to the packed type.
    value = materializeSBVToPackedConversion(*this, dstPacked, value, loc,
                                             fallible);
    if (!value)
      return {};
 
    assert(value.getType() == type);
    return value;
  }
 
  // Convert from FormatStringType to StringType
  if (isa<moore::StringType>(type) &&
      isa<moore::FormatStringType>(value.getType())) {
    return builder.createOrFold<moore::FormatStringToStringOp>(loc, value);
  }
 
  // Convert from StringType to FormatStringType
  if (isa<moore::FormatStringType>(type) &&
      isa<moore::StringType>(value.getType())) {
    return builder.createOrFold<moore::FormatStringOp>(loc, value);
  }
 
  // If converting between two queue types of the same element type, then we
  // just need to convert the queue bounds.
  if (isa<moore::QueueType>(type) && isa<moore::QueueType>(value.getType()) &&
      cast<moore::QueueType>(type).getElementType() ==
          cast<moore::QueueType>(value.getType()).getElementType())
    return builder.createOrFold<moore::QueueResizeOp>(loc, type, value);
 
  // Convert from UnpackedArrayType to QueueType
  if (isa<moore::QueueType>(type) &&
      isa<moore::UnpackedArrayType>(value.getType())) {
    auto queueElType = dyn_cast<moore::QueueType>(type).getElementType();
    auto unpackedArrayElType =
        dyn_cast<moore::UnpackedArrayType>(value.getType()).getElementType();
 
    if (queueElType == unpackedArrayElType) {
      return builder.createOrFold<moore::QueueFromUnpackedArrayOp>(loc, type,
                                                                   value);
    }
  }
  // Convert from fixed-size unpacked array to open unpacked array
  auto srcUArray = dyn_cast<moore::UnpackedArrayType>(value.getType());
  auto dstOpenUArray = dyn_cast<moore::OpenUnpackedArrayType>(type);
  if (srcUArray && dstOpenUArray) {
    auto openUnpackedArrayElType = dstOpenUArray.getElementType();
    auto unpackedArrayElType = srcUArray.getElementType();
 
    if (openUnpackedArrayElType == unpackedArrayElType)
      return builder.createOrFold<moore::OpenUArrayFromUnpackedArrayOp>(
          loc, type, value);
  }
  // Handle Real To Int conversion
  if (dstInt && isa<moore::RealType>(value.getType())) {
    auto twoValInt = builder.createOrFold<moore::RealToIntOp>(
        loc, dstInt.getTwoValued(), value);
    return materializeConversion(type, twoValInt, true, loc, fallible);
  }
 
  // Handle Int to Real conversion
  if (isa<moore::RealType>(type) && isa<moore::IntType>(value.getType())) {
    Value twoValInt;
    // Check if int needs to be converted to two-valued first
    if (dyn_cast<moore::IntType>(value.getType()).getDomain() ==
        moore::Domain::TwoValued)
      twoValInt = value;
    else
      twoValInt = materializeConversion(
          dyn_cast<moore::IntType>(value.getType()).getTwoValued(), value, true,
          loc);
 
    if (isSigned)
      return builder.createOrFold<moore::SIntToRealOp>(loc, type, twoValInt);
    return builder.createOrFold<moore::UIntToRealOp>(loc, type, twoValInt);
  }
 
  auto getBuiltinFloatType = [&](moore::RealType type) -> Type {
    if (type.getWidth() == moore::RealWidth::f32)
      return mlir::Float32Type::get(builder.getContext());
 
    return mlir::Float64Type::get(builder.getContext());
  };
 
  // Handle f64/f32 to time conversion
  if (isa<moore::TimeType>(type) && isa<moore::RealType>(value.getType())) {
    auto intType =
        moore::IntType::get(builder.getContext(), 64, Domain::TwoValued);
    Type floatType =
        getBuiltinFloatType(cast<moore::RealType>(value.getType()));
    auto scale = moore::ConstantRealOp::create(
        builder, loc, value.getType(),
        FloatAttr::get(floatType, getTimeScaleInFemtoseconds(*this)));
    auto scaled = builder.createOrFold<moore::MulRealOp>(loc, value, scale);
    auto asInt = moore::RealToIntOp::create(builder, loc, intType, scaled);
    auto asLogic = moore::IntToLogicOp::create(builder, loc, asInt);
    return moore::LogicToTimeOp::create(builder, loc, asLogic);
  }
 
  // Handle time to f64/f32 conversion
  if (isa<moore::RealType>(type) && isa<moore::TimeType>(value.getType())) {
    auto asLogic = moore::TimeToLogicOp::create(builder, loc, value);
    auto asInt = moore::LogicToIntOp::create(builder, loc, asLogic);
    auto asReal = moore::UIntToRealOp::create(builder, loc, type, asInt);
    Type floatType = getBuiltinFloatType(cast<moore::RealType>(type));
    auto scale = moore::ConstantRealOp::create(
        builder, loc, type,
        FloatAttr::get(floatType, getTimeScaleInFemtoseconds(*this)));
    return moore::DivRealOp::create(builder, loc, asReal, scale);
  }
 
  // Handle Int to String
  if (isa<moore::StringType>(type)) {
    if (auto intType = dyn_cast<moore::IntType>(value.getType())) {
      if (intType.getDomain() == moore::Domain::FourValued)
        value = moore::LogicToIntOp::create(builder, loc, value);
      return moore::IntToStringOp::create(builder, loc, value);
    }
  }
 
  // Handle String to Int
  if (auto intType = dyn_cast<moore::IntType>(type)) {
    if (isa<moore::StringType>(value.getType())) {
      value = moore::StringToIntOp::create(builder, loc, intType.getTwoValued(),
                                           value);
 
      if (intType.getDomain() == moore::Domain::FourValued)
        return moore::IntToLogicOp::create(builder, loc, value);
 
      return value;
    }
  }
 
  // Handle Int to FormatString
  if (isa<moore::FormatStringType>(type)) {
    auto asStr = materializeConversion(moore::StringType::get(getContext()),
                                       value, isSigned, loc);
    if (!asStr)
      return {};
    return moore::FormatStringOp::create(builder, loc, asStr, {}, {}, {});
  }
 
  if (isa<moore::RealType>(type) && isa<moore::RealType>(value.getType()))
    return builder.createOrFold<moore::ConvertRealOp>(loc, type, value);
 
  if (isa<moore::ClassHandleType>(type) &&
      isa<moore::ClassHandleType>(value.getType()))
    return maybeUpcastHandle(*this, value, cast<moore::ClassHandleType>(type));
 
  if (!fallible)
    mlir::emitError(loc) << "unsupported conversion from " << value.getType()
                         << " to " << type;
  return {};
}
 
/// Helper function to convert real math builtin functions that take exactly
/// one argument.
template <typename OpTy>
static Value
convertRealMathBI(Context &context, Location loc, StringRef name,
                  std::span<const slang::ast::Expression *const> args) {
  // Slang already checks the arity of real math builtins.
  assert(args.size() == 1 && "real math builtin expects 1 argument");
  auto value = context.convertRvalueExpression(*args[0]);
  if (!value)
    return {};
  return OpTy::create(context.builder, loc, value);
}
 
/// Helper function to convert real math builtin functions that take exactly
/// two arguments.
template <typename OpTy>
static Value
convertRealMathTwoBI(Context &context, Location loc, StringRef name,
                     std::span<const slang::ast::Expression *const> args) {
  // Slang already checks the arity of real math builtins.
  assert(args.size() == 2 && "real math builtin expects 2 arguments");
  auto realType =
      moore::RealType::get(context.getContext(), moore::RealWidth::f64);
  auto lhs = context.convertRvalueExpression(*args[0], realType);
  auto rhs = context.convertRvalueExpression(*args[1], realType);
  if (!lhs || !rhs)
    return {};
  return OpTy::create(context.builder, loc, lhs, rhs);
}
 
static LogicalResult
emitScanAssignments(Context &context, const Context::ScanStringResult &result,
                    Location loc) {
  auto &builder = context.builder;
  auto newBlockAfter = [&](Block *after) -> Block * {
    auto block = std::make_unique<Block>();
    block->insertAfter(after);
    return block.release();
  };
 
  for (auto [destExpr, value, matched] : result.assignments) {
    auto lhs = context.convertLvalueExpression(*destExpr);
    if (!lhs)
      return failure();
    auto cond = moore::ToBuiltinIntOp::create(builder, loc, matched);
 
    auto *assignBlock = newBlockAfter(builder.getInsertionBlock());
    auto *continuedBlock = newBlockAfter(assignBlock);
    mlir::cf::CondBranchOp::create(builder, loc, cond, assignBlock,
                                   continuedBlock);
 
    builder.setInsertionPointToEnd(assignBlock);
    moore::BlockingAssignOp::create(builder, loc, lhs, value);
    mlir::cf::BranchOp::create(builder, loc, continuedBlock);
 
    builder.setInsertionPointToEnd(continuedBlock);
  }
  return success();
}
 
//===----------------------------------------------------------------------===//
// Enum Built-in Method Helpers
//===----------------------------------------------------------------------===//
 
/// The `next`, `prev`, and `name` built-in methods on enums have to locate the
/// value they are called on in the list of enumerands at runtime. Slang folds
/// these calls away wherever the value is constant, so what remains are the
/// cases that require an actual computation. Instead of inlining that
/// computation at every call site, we emit one helper function per enum type
/// and method, and turn the calls into plain function calls.
///
/// All helpers start with a chain of blocks that compares the value against
/// each enumerand in turn. A match branches to a common match block, carrying
/// what the comparison found along as a block argument. Running off the end of
/// the chain means the value is not a member of the enumeration, in which case
/// `name` returns an empty string and `next`/`prev` return the enum's default
/// value, as mandated by IEEE 1800-2023 § 6.19.5.
///
/// For `name` the block argument is the enumerand's name, which the match block
/// simply returns. For `next` and `prev` it is the position of the value among
/// the enumerands. The match block offsets that position by the step count,
/// which is only known at runtime, wraps it around at both ends of the
/// enumerand list, and uses it to index an array of all enumerand values.
mlir::func::FuncOp
Context::getOrCreateEnumHelper(const slang::ast::Type &type,
                               slang::parsing::KnownSystemName method,
                               Location loc) {
  using ksn = slang::parsing::KnownSystemName;
  const auto &enumType = type.getCanonicalType().as<slang::ast::EnumType>();
  auto &slot = enumHelpers[{&enumType, method}];
  if (slot)
    return slot;
  bool isName = method == ksn::Name;
 
  // Determine the types involved before creating any IR, such that failures do
  // not leave a half-built function behind.
  auto valueType = dyn_cast_or_null<moore::PackedType>(convertType(enumType));
  if (!valueType)
    return {};
  auto posType = moore::IntType::getInt(getContext(), 32);
  auto resultType =
      isName ? Type(moore::StringType::get(getContext())) : Type(valueType);
 
  // Pick an insertion point for this helper according to the source file
  // location of the enum declaration.
  OpBuilder::InsertionGuard guard(builder);
  auto locationKey = LocationKey::get(enumType.location, sourceManager);
  auto it = orderedRootOps.upper_bound(locationKey);
  if (it == orderedRootOps.end())
    builder.setInsertionPointToEnd(intoModuleOp.getBody());
  else
    builder.setInsertionPoint(it->second);
  auto helperLoc = convertLocation(enumType.location);
 
  // Name the helper after the method and the name the enum was declared under,
  // if any. The symbol table uniquifies the name when the function is inserted.
  StringRef typeName = type.name;
  auto helperName = StringAttr::get(
      getContext(), Twine("enum.") + slang::parsing::toString(method) + "." +
                        (typeName.empty() ? "anon" : typeName));
 
  SmallVector<Type> argTypes{valueType};
  if (!isName)
    argTypes.push_back(posType); // add the step count argument
  auto funcOp =
      mlir::func::FuncOp::create(builder, helperLoc, helperName,
                                 builder.getFunctionType(argTypes, resultType));
  SymbolTable::setSymbolVisibility(funcOp, SymbolTable::Visibility::Private);
 
  orderedRootOps.insert(it, {locationKey, funcOp});
  symbolTable.insert(funcOp);
  slot = funcOp;
 
  // Materialize the enumerand values in the entry block, where they dominate
  // both the comparison chain and the lookup table below.
  auto &bodyRegion = funcOp.getBody();
  auto *entryBlock = funcOp.addEntryBlock();
  auto value = entryBlock->getArgument(0);
  builder.setInsertionPointToEnd(entryBlock);
  SmallVector<Value> enumerandValues;
  for (const auto &enumerand : enumType.values()) {
    auto constant = materializeSVInt(enumerand.getValue().integer(), enumType,
                                     convertLocation(enumerand.location));
    if (!constant)
      return {};
    enumerandValues.push_back(constant);
  }
 
  // Assemble the array that maps a position among the enumerands back to the
  // corresponding value. Array elements are listed starting at the highest
  // index, so the values go in reverse.
  Value table;
  if (!isName) {
    auto tableType = moore::ArrayType::get(enumerandValues.size(), valueType);
    table = moore::ArrayCreateOp::create(
        builder, helperLoc, tableType,
        SmallVector<Value>(llvm::reverse(enumerandValues)));
  }
 
  // Create the block that the comparison chain hands its findings to. For
  // `name` this simply returns the name it is handed; for `next` and `prev` it
  // receives the position of the value among the enumerands and computes the
  // result from it.
  auto *matchBlock = &bodyRegion.emplaceBlock();
  matchBlock->addArgument(isName ? resultType : Type(posType), helperLoc);
 
  // Compare the value against each enumerand in turn. A match hands over the
  // enumerand's name for `name`, and its position for `next` and `prev`.
  for (auto [position, enumerand] : llvm::enumerate(enumType.values())) {
    auto enumerandLoc = convertLocation(enumerand.location);
    auto matches = moore::CaseEqOp::create(builder, enumerandLoc, value,
                                           enumerandValues[position]);
    auto condition =
        moore::ToBuiltinIntOp::create(builder, enumerandLoc, matches);
 
    Value matchResult;
    if (isName) {
      auto intType =
          moore::IntType::getInt(getContext(), enumerand.name.size() * 8);
      auto bytes = moore::ConstantStringOp::create(builder, enumerandLoc,
                                                   intType, enumerand.name);
      matchResult = moore::IntToStringOp::create(builder, enumerandLoc, bytes);
    } else {
      matchResult = moore::ConstantOp::create(builder, enumerandLoc, posType,
                                              static_cast<int64_t>(position));
    }
 
    auto *mismatchBlock = &bodyRegion.emplaceBlock();
    mlir::cf::CondBranchOp::create(builder, enumerandLoc, condition, matchBlock,
                                   ValueRange{matchResult}, mismatchBlock,
                                   ValueRange{});
    builder.setInsertionPointToEnd(mismatchBlock);
  }
 
  // Control reaches here if the value is not a member of the enumeration.
  // `name` hands the empty string to the match block alongside the names from
  // the comparison chain, while `next` and `prev` return the enum's default
  // value directly.
  if (isName) {
    auto intType = moore::IntType::getInt(getContext(), 0);
    auto bytes =
        moore::ConstantStringOp::create(builder, helperLoc, intType, "");
    Value empty = moore::IntToStringOp::create(builder, helperLoc, bytes);
    mlir::cf::BranchOp::create(builder, helperLoc, matchBlock, empty);
  } else {
    auto fallback =
        materializeConstant(enumType.getDefaultValue(), enumType, helperLoc);
    if (!fallback)
      return {};
    mlir::func::ReturnOp::create(builder, helperLoc, fallback);
  }
 
  builder.setInsertionPointToEnd(matchBlock);
  Value result = matchBlock->getArgument(0);
  if (!isName) {
    // Offset the position of the value by the step count, wrapping around at
    // both ends of the enumerand list, and look the resulting position up in
    // the table. The step count is reduced modulo the number of enumerands
    // first, such that the offsetting cannot overflow.
    Value numValues =
        moore::ConstantOp::create(builder, helperLoc, posType,
                                  static_cast<int64_t>(enumerandValues.size()));
    Value step = moore::ModUOp::create(builder, helperLoc,
                                       funcOp.getArgument(1), numValues);
    if (method == ksn::Prev)
      step = moore::SubOp::create(builder, helperLoc, numValues, step);
    Value offset = moore::AddOp::create(builder, helperLoc, result, step);
    Value position =
        moore::ModUOp::create(builder, helperLoc, offset, numValues);
    result = moore::DynExtractOp::create(builder, helperLoc, valueType, table,
                                         position);
  }
  mlir::func::ReturnOp::create(builder, helperLoc, result);
 
  // Move the match block past the comparison chain such that the blocks in the
  // finished function appear in execution order.
  matchBlock->moveBefore(&bodyRegion, bodyRegion.end());
  return funcOp;
}
 
Value Context::convertSystemCall(
    const slang::ast::SystemSubroutine &subroutine, Location loc,
    std::span<const slang::ast::Expression *const> args) {
  using ksn = slang::parsing::KnownSystemName;
  StringRef name = subroutine.name;
  auto nameId = subroutine.knownNameId;
  size_t numArgs = args.size();
 
  //===--------------------------------------------------------------------===//
  // Random Number System Functions
  //===--------------------------------------------------------------------===//
 
  // $urandom, $random, and $urandom_range all map to a single
  // moore.builtin.urandom_range primitive with (minval, maxval, seed).
  if (nameId == ksn::URandom || nameId == ksn::Random) {
    auto i32Ty = moore::IntType::getInt(builder.getContext(), 32);
    auto minval = moore::ConstantOp::create(builder, loc, i32Ty, 0);
    auto maxval =
        moore::ConstantOp::create(builder, loc, i32Ty, APInt::getAllOnes(32));
    Value seed;
    if (numArgs == 1) {
      seed = convertLvalueExpression(*args[0]);
      if (!seed)
        return {};
    }
    return moore::UrandomRangeBIOp::create(builder, loc, minval, maxval, seed);
  }
 
  if (nameId == ksn::URandomRange) {
    auto i32Ty = moore::IntType::getInt(builder.getContext(), 32);
    auto maxval = convertRvalueExpression(*args[0]);
    if (!maxval)
      return {};
    Value minval;
    if (numArgs >= 2) {
      minval = convertRvalueExpression(*args[1]);
      if (!minval)
        return {};
    } else {
      minval = moore::ConstantOp::create(builder, loc, i32Ty, 0);
    }
    return moore::UrandomRangeBIOp::create(builder, loc, minval, maxval,
                                           Value{});
  }
 
  //===--------------------------------------------------------------------===//
  // Time System Functions
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::Time || nameId == ksn::STime || nameId == ksn::RealTime) {
    // Slang already checks the arity of time functions.
    assert(numArgs == 0 && "time functions take no arguments");
    return moore::TimeBIOp::create(builder, loc);
  }
 
  //===--------------------------------------------------------------------===//
  // Math System Functions
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::Clog2) {
    // Slang already checks the arity of `$clog2`.
    assert(numArgs == 1 && "`$clog2` takes 1 argument");
    auto value = convertRvalueExpression(*args[0]);
    if (!value)
      return {};
    value = convertToSimpleBitVector(value);
    if (!value)
      return {};
    return moore::Clog2BIOp::create(builder, loc, value);
  }
 
  //===--------------------------------------------------------------------===//
  // Bit Vector System Functions
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::IsUnknown) {
    assert(numArgs == 1 && "`$isunknown` takes 1 argument");
    auto value = convertRvalueExpression(*args[0]);
    if (!value)
      return {};
 
    if (!isa<moore::IntType>(value.getType())) {
      if (!isa<moore::PackedType>(value.getType())) {
        mlir::emitError(loc) << "expected integer argument for `$isunknown`";
        return {};
      }
      value = materializePackedToSBVConversion(value, loc,
                                               /*fallible=*/false);
      if (!value)
        return {};
    }
    auto valTy = dyn_cast<moore::IntType>(value.getType());
    return getIsUnknown(builder, loc, value, valTy, getContext());
  }
 
  if (nameId == ksn::OneHot0 || nameId == ksn::OneHot) {
    assert(numArgs == 1 && "`$onehot`/`$onehot0` takes 1 argument");
    auto value = convertRvalueExpression(*args[0]);
    if (!value)
      return {};
    if (!isa<moore::IntType>(value.getType())) {
      if (!isa<moore::PackedType>(value.getType())) {
        mlir::emitError(loc)
            << "expected integer argument for `$onehot`/`$onehot0`";
        return {};
      }
      value = materializePackedToSBVConversion(value, loc,
                                               /*fallible=*/false);
      if (!value)
        return {};
    }
    auto valTy = dyn_cast<moore::IntType>(value.getType());
    if (!valTy) {
      mlir::emitError(loc) << "expected integer argument for `"
                           << subroutine.name << "`";
      return {};
    }
 
    // In SystemVerilog, $onehot/$onehot0 return 1'b0 if the expression
    // contains any unknown (x/z) bits. Detect and squash if four-valued.
    Value isUnknown;
    if (valTy.getDomain() == Domain::FourValued) {
      Value isUnknownMoore =
          getIsUnknown(builder, loc, value, valTy, getContext());
      isUnknown =
          builder.createOrFold<moore::ToBuiltinIntOp>(loc, isUnknownMoore);
    }
 
    // Coerce four-valued input to two-valued for the comb ops.
    Value intVal = coerceToBuiltinInt(builder, loc, value, valTy);
 
    // Compute onehot0: (value & (value - 1)) == 0
    auto one = hw::ConstantOp::create(builder, loc, intVal.getType(), 1);
    auto minusOne = comb::SubOp::create(builder, loc, intVal, one);
    auto anded = comb::AndOp::create(builder, loc, intVal, minusOne);
    auto zero = hw::ConstantOp::create(builder, loc, intVal.getType(), 0);
    Value result = comb::ICmpOp::create(builder, loc, comb::ICmpPredicate::eq,
                                        anded, zero, false);
 
    // For $onehot, additionally require value != 0.
    if (nameId == ksn::OneHot) {
      auto isNotZero = comb::ICmpOp::create(
          builder, loc, comb::ICmpPredicate::ne, intVal, zero, false);
      result = comb::AndOp::create(builder, loc, result, isNotZero);
    }
 
    // If four-valued, squash to 0 when unknown bits exist.
    if (isUnknown) {
      Value zeroI1 =
          hw::ConstantOp::create(builder, loc, builder.getI1Type(), 0);
      result = comb::MuxOp::create(builder, loc, isUnknown, zeroI1, result);
      Value resultMoore = moore::FromBuiltinIntOp::create(builder, loc, result);
      return moore::IntToLogicOp::create(builder, loc, resultMoore).getResult();
    }
    return moore::FromBuiltinIntOp::create(builder, loc, result);
  }
 
  if (nameId == ksn::CountOnes) {
    assert(numArgs == 1 && "`$countones` takes 1 argument");
    auto value = convertRvalueExpression(*args[0]);
    if (!value)
      return {};
    if (!isa<moore::IntType>(value.getType())) {
      if (!isa<moore::PackedType>(value.getType())) {
        mlir::emitError(loc) << "expected integer argument for `$countones`";
        return {};
      }
      value = materializePackedToSBVConversion(value, loc,
                                               /*fallible=*/false);
      if (!value)
        return {};
    }
    auto valTy = dyn_cast<moore::IntType>(value.getType());
    if (!valTy) {
      mlir::emitError(loc) << "expected integer argument for `$countones`";
      return {};
    }
 
    // Coerce four-valued input to two-valued for the comb ops.
    Value intVal = coerceToBuiltinInt(builder, loc, value, valTy);
 
    // Popcount: extract each bit, zero-extend to result width, and sum.
    auto builtinIntTy = cast<IntegerType>(intVal.getType());
    unsigned width = builtinIntTy.getWidth();
    unsigned resultWidth = llvm::Log2_32_Ceil(width + 1);
    auto i1Ty = builder.getI1Type();
    unsigned padWidth = resultWidth - 1;
    auto zeros = hw::ConstantOp::create(builder, loc,
                                        builder.getIntegerType(padWidth), 0);
 
    // Zero-extend the first bit to seed the accumulator.
    auto bit0 = comb::ExtractOp::create(builder, loc, i1Ty, intVal, 0);
    Value sum = comb::ConcatOp::create(builder, loc, ValueRange{zeros, bit0});
 
    for (unsigned i = 1; i < width; ++i) {
      auto bit = comb::ExtractOp::create(builder, loc, i1Ty, intVal, i);
      auto extended =
          comb::ConcatOp::create(builder, loc, ValueRange{zeros, bit});
      sum = comb::AddOp::create(builder, loc, sum, extended);
    }
 
    // Wrap back into Moore type (unsigned — CountOnes result is never signed).
    return moore::FromBuiltinIntOp::create(builder, loc, sum);
  }
 
  // Real math functions (all take 1 real argument)
  if (nameId == ksn::Ln)
    return convertRealMathBI<moore::LnBIOp>(*this, loc, name, args);
  if (nameId == ksn::Log10)
    return convertRealMathBI<moore::Log10BIOp>(*this, loc, name, args);
  if (nameId == ksn::Exp)
    return convertRealMathBI<moore::ExpBIOp>(*this, loc, name, args);
  if (nameId == ksn::Sqrt)
    return convertRealMathBI<moore::SqrtBIOp>(*this, loc, name, args);
  if (nameId == ksn::Floor)
    return convertRealMathBI<moore::FloorBIOp>(*this, loc, name, args);
  if (nameId == ksn::Ceil)
    return convertRealMathBI<moore::CeilBIOp>(*this, loc, name, args);
  if (nameId == ksn::Sin)
    return convertRealMathBI<moore::SinBIOp>(*this, loc, name, args);
  if (nameId == ksn::Cos)
    return convertRealMathBI<moore::CosBIOp>(*this, loc, name, args);
  if (nameId == ksn::Tan)
    return convertRealMathBI<moore::TanBIOp>(*this, loc, name, args);
  if (nameId == ksn::Asin)
    return convertRealMathBI<moore::AsinBIOp>(*this, loc, name, args);
  if (nameId == ksn::Acos)
    return convertRealMathBI<moore::AcosBIOp>(*this, loc, name, args);
  if (nameId == ksn::Atan)
    return convertRealMathBI<moore::AtanBIOp>(*this, loc, name, args);
  if (nameId == ksn::Sinh)
    return convertRealMathBI<moore::SinhBIOp>(*this, loc, name, args);
  if (nameId == ksn::Cosh)
    return convertRealMathBI<moore::CoshBIOp>(*this, loc, name, args);
  if (nameId == ksn::Tanh)
    return convertRealMathBI<moore::TanhBIOp>(*this, loc, name, args);
  if (nameId == ksn::Asinh)
    return convertRealMathBI<moore::AsinhBIOp>(*this, loc, name, args);
  if (nameId == ksn::Acosh)
    return convertRealMathBI<moore::AcoshBIOp>(*this, loc, name, args);
  if (nameId == ksn::Atanh)
    return convertRealMathBI<moore::AtanhBIOp>(*this, loc, name, args);
  // Real math functions (all take 2 real arguments)
  if (nameId == ksn::Pow)
    return convertRealMathTwoBI<moore::PowRealOp>(*this, loc, name, args);
  if (nameId == ksn::Atan2)
    return convertRealMathTwoBI<moore::Atan2BIOp>(*this, loc, name, args);
  if (nameId == ksn::Hypot)
    return convertRealMathTwoBI<moore::HypotBIOp>(*this, loc, name, args);
 
  //===--------------------------------------------------------------------===//
  // Type Conversion System Functions
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::Itor) {
    assert(numArgs == 1 && "`$itor` takes 1 argument");
    auto realType = moore::RealType::get(getContext(), moore::RealWidth::f64);
    return convertRvalueExpression(*args[0], realType);
  }
 
  if (nameId == ksn::Rtoi) {
    assert(numArgs == 1 && "`$rtoi` takes 1 argument");
    auto intType = moore::IntType::get(getContext(), 32, Domain::TwoValued);
    return convertRvalueExpression(*args[0], intType);
  }
 
  if (nameId == ksn::Signed || nameId == ksn::Unsigned) {
    // Slang already checks the arity of `$signed`/`$unsigned`.
    assert(numArgs == 1 && "`$signed`/`$unsigned` take 1 argument");
    // These are just passthroughs in the IR; signedness is carried on the Slang
    // AST type which we use to convert the IR.
    return convertRvalueExpression(*args[0]);
  }
 
  if (nameId == ksn::RealToBits)
    return convertRealMathBI<moore::RealtobitsBIOp>(*this, loc, name, args);
  if (nameId == ksn::BitsToReal)
    return convertRealMathBI<moore::BitstorealBIOp>(*this, loc, name, args);
  if (nameId == ksn::ShortrealToBits)
    return convertRealMathBI<moore::ShortrealtobitsBIOp>(*this, loc, name,
                                                         args);
  if (nameId == ksn::BitsToShortreal)
    return convertRealMathBI<moore::BitstoshortrealBIOp>(*this, loc, name,
                                                         args);
 
  if (nameId == ksn::Cast) {
    assert(numArgs == 2 && "`cast` takes 2 arguments");
    auto *dstExpr = args[0];
    auto dstType = convertType(*dstExpr->type);
    if (!dstType)
      return {};
 
    if (auto *assign = dstExpr->as_if<slang::ast::AssignmentExpression>())
      dstExpr = &assign->left();
    auto dst = convertLvalueExpression(*dstExpr);
    if (!dst)
      return {};
 
    auto src = convertRvalueExpression(*args[1]);
    if (!src)
      return {};
    // Class-typed $cast (upcast/downcast) is intentionally left for follow-up.
    if (isa<moore::ClassHandleType>(dstType) ||
        isa<moore::ClassHandleType>(src.getType())) {
      auto i1Ty = moore::IntType::getInt(builder.getContext(), 1);
      return moore::ConstantOp::create(builder, loc, i1Ty, 0,
                                       /*isSigned=*/false);
    }
    auto converted = materializeConversion(
        dstType, src, args[1]->type->isSigned(), loc, /*fallible=*/true);
    auto i1Ty = moore::IntType::getInt(builder.getContext(), 1);
    if (!converted)
      return moore::ConstantOp::create(builder, loc, i1Ty, 0,
                                       /*isSigned=*/false);
    moore::BlockingAssignOp::create(builder, loc, dst, converted);
    return moore::ConstantOp::create(builder, loc, i1Ty, 1,
                                     /*isSigned=*/false);
  }
 
  //===--------------------------------------------------------------------===//
  // String Methods
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::Len) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 1 && "`len` takes 1 argument");
    auto stringType = moore::StringType::get(getContext());
    auto value = convertRvalueExpression(*args[0], stringType);
    if (!value)
      return {};
    return moore::StringLenOp::create(builder, loc, value);
  }
 
  if (nameId == ksn::Getc) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 2 && "`getc` takes 2 arguments");
    auto stringType = moore::StringType::get(getContext());
    auto str = convertRvalueExpression(*args[0], stringType);
    auto index = convertRvalueExpression(*args[1]);
    if (!str || !index)
      return {};
    return moore::StringGetOp::create(builder, loc, str, index);
  }
 
  if (nameId == ksn::ToUpper) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 1 && "`toupper` takes 1 argument");
    auto stringType = moore::StringType::get(getContext());
    auto value = convertRvalueExpression(*args[0], stringType);
    if (!value)
      return {};
    return moore::StringToUpperOp::create(builder, loc, value);
  }
 
  if (nameId == ksn::ToLower) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 1 && "`tolower` takes 1 argument");
    auto stringType = moore::StringType::get(getContext());
    auto value = convertRvalueExpression(*args[0], stringType);
    if (!value)
      return {};
    return moore::StringToLowerOp::create(builder, loc, value);
  }
 
  if (nameId == ksn::Compare || nameId == ksn::ICompare) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 2);
    auto stringType = moore::StringType::get(getContext());
    auto lhs = convertRvalueExpression(*args[0], stringType);
    auto rhs = convertRvalueExpression(*args[1], stringType);
    if (!lhs || !rhs)
      return {};
    if (nameId == ksn::Compare)
      return moore::StringCompareOp::create(builder, loc, lhs, rhs);
    return moore::StringICompareOp::create(builder, loc, lhs, rhs);
  }
 
  if (nameId == ksn::Substr) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 3 && "`substr` takes 3 arguments");
    auto stringType = moore::StringType::get(getContext());
    auto str = convertRvalueExpression(*args[0], stringType);
    auto start = convertRvalueExpression(*args[1]);
    auto end = convertRvalueExpression(*args[2]);
    if (!str || !start || !end)
      return {};
    return moore::StringSubstrOp::create(builder, loc, str, start, end);
  }
 
  if (nameId == ksn::AToI || nameId == ksn::AToHex || nameId == ksn::AToOct ||
      nameId == ksn::AToBin) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 1 && "`atoi/hex/oct/bin` takes 1 argument");
    auto stringType = moore::StringType::get(getContext());
    auto str = convertRvalueExpression(*args[0], stringType);
    if (!str)
      return {};
    auto integerType = moore::IntType::getLogic(builder.getContext(), 32);
    switch (nameId) {
    case ksn::AToI:
      return moore::StringAtoiOp::create(builder, loc, integerType, str);
    case ksn::AToHex:
      return moore::StringAtohexOp::create(builder, loc, integerType, str);
    case ksn::AToOct:
      return moore::StringAtooctOp::create(builder, loc, integerType, str);
    case ksn::AToBin:
      return moore::StringAtobinOp::create(builder, loc, integerType, str);
    default:
      llvm_unreachable("unexpected string to integer conversion");
    }
  }
 
  if (nameId == ksn::AToReal) {
    // Slang already checks the arity of string methods.
    assert(numArgs == 1 && "`atoreal` takes 1 argument");
    auto stringType = moore::StringType::get(getContext());
    auto str = convertRvalueExpression(*args[0], stringType);
    if (!str)
      return {};
    auto realType = moore::RealType::get(getContext(), moore::RealWidth::f64);
    return moore::StringAtorealOp::create(builder, loc, realType, str);
  }
 
  //===--------------------------------------------------------------------===//
  // Queue Methods
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::ArraySize) {
    // Slang already checks the arity of `size`.
    assert(numArgs == 1 && "`size` takes 1 argument");
    if (args[0]->type->isQueue()) {
      auto value = convertRvalueExpression(*args[0]);
      if (!value)
        return {};
      return moore::QueueSizeBIOp::create(builder, loc, value);
    }
    if (args[0]->type->getCanonicalType().kind ==
        slang::ast::SymbolKind::DynamicArrayType) {
      auto value = convertRvalueExpression(*args[0]);
      if (!value)
        return {};
      return moore::OpenUArraySizeOp::create(builder, loc, value);
    }
    if (args[0]->type->isAssociativeArray()) {
      auto value = convertLvalueExpression(*args[0]);
      if (!value)
        return {};
      return moore::AssocArraySizeOp::create(builder, loc, value);
    }
    emitError(loc) << "unsupported member function `size` on type `"
                   << args[0]->type->toString() << "`";
    return {};
  }
 
  if (nameId == ksn::Delete) {
    // Slang already checks the arity of `delete`.
    assert(numArgs == 1 && "`delete` takes 1 argument");
    if (args[0]->type->getCanonicalType().kind ==
        slang::ast::SymbolKind::DynamicArrayType) {
      auto value = convertRvalueExpression(*args[0]);
      if (!value)
        return {};
      return moore::OpenUArrayDeleteOp::create(builder, loc, value);
    }
    emitError(loc) << "unsupported member function `delete` on type `"
                   << args[0]->type->toString() << "`";
    return {};
  }
 
  if (nameId == ksn::PopBack) {
    // Slang already checks the arity and applicability of `pop_back`.
    assert(numArgs == 1 && "`pop_back` takes 1 argument");
    assert(args[0]->type->isQueue() && "`pop_back` is only valid on queues");
    auto value = convertLvalueExpression(*args[0]);
    if (!value)
      return {};
    return moore::QueuePopBackOp::create(builder, loc, value);
  }
 
  if (nameId == ksn::PopFront) {
    // Slang already checks the arity and applicability of `pop_front`.
    assert(numArgs == 1 && "`pop_front` takes 1 argument");
    assert(args[0]->type->isQueue() && "`pop_front` is only valid on queues");
    auto value = convertLvalueExpression(*args[0]);
    if (!value)
      return {};
    return moore::QueuePopFrontOp::create(builder, loc, value);
  }
 
  //===--------------------------------------------------------------------===//
  // Associative Array Methods
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::Num) {
    if (args[0]->type->isAssociativeArray()) {
      assert(numArgs == 1 && "`num` takes 1 argument");
      auto value = convertLvalueExpression(*args[0]);
      if (!value)
        return {};
      return moore::AssocArraySizeOp::create(builder, loc, value);
    }
    emitError(loc) << "unsupported system call `" << name << "`";
    return {};
  }
 
  if (nameId == ksn::Exists) {
    // Slang already checks the arity and applicability of `exists`.
    assert(numArgs == 2 && "`exists` takes 2 arguments");
    assert(args[0]->type->isAssociativeArray() &&
           "`exists` is only valid on associative arrays");
    auto array = convertLvalueExpression(*args[0]);
    auto key = convertRvalueExpression(*args[1]);
    if (!array || !key)
      return {};
    return moore::AssocArrayExistsOp::create(builder, loc, array, key);
  }
 
  if ((nameId == ksn::First || nameId == ksn::Last || nameId == ksn::Next ||
       nameId == ksn::Prev) &&
      args[0]->type->isAssociativeArray()) {
    assert(numArgs == 2 && "traversal methods take 2 arguments");
    auto array = convertLvalueExpression(*args[0]);
    auto key = convertLvalueExpression(*args[1]);
    if (!array || !key)
      return {};
    if (nameId == ksn::First)
      return moore::AssocArrayFirstOp::create(builder, loc, array, key);
    if (nameId == ksn::Last)
      return moore::AssocArrayLastOp::create(builder, loc, array, key);
    if (nameId == ksn::Next)
      return moore::AssocArrayNextOp::create(builder, loc, array, key);
    if (nameId == ksn::Prev)
      return moore::AssocArrayPrevOp::create(builder, loc, array, key);
    llvm_unreachable("all traversal cases handled above");
  }
 
  //===--------------------------------------------------------------------===//
  // File I/O System Functions
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::FOpen) {
    assert(numArgs >= 1 && numArgs <= 2 && "`$fopen` takes 1 or 2 arguments");
    auto filename =
        convertRvalueExpression(*args[0], moore::StringType::get(getContext()));
    if (!filename)
      return {};
    moore::FOpenModeAttr modeAttr;
    if (numArgs == 2) {
      auto *strLit = args[1]
                         ->unwrapImplicitConversions()
                         .as_if<slang::ast::StringLiteral>();
      if (!strLit)
        return emitError(loc) << "$fopen mode must be a string literal",
               Value{};
 
      auto mode =
          llvm::StringSwitch<std::optional<moore::FOpenMode>>(
              strLit->getValue())
              .Cases({"r", "rb"}, moore::FOpenMode::Read)
              .Cases({"w", "wb"}, moore::FOpenMode::Write)
              .Cases({"a", "ab"}, moore::FOpenMode::Append)
              .Cases({"r+", "r+b", "rb+"}, moore::FOpenMode::ReadUpdate)
              .Cases({"w+", "w+b", "wb+"}, moore::FOpenMode::WriteUpdate)
              .Cases({"a+", "a+b", "ab+"}, moore::FOpenMode::AppendUpdate)
              .Default(std::nullopt);
 
      if (!mode)
        return emitError(loc)
                   << "invalid $fopen mode '" << strLit->getValue() << "'",
               Value{};
      modeAttr = moore::FOpenModeAttr::get(getContext(), *mode);
    }
    return moore::FOpenBIOp::create(builder, loc, filename, modeAttr);
  }
 
  //===--------------------------------------------------------------------===//
  // Command Line Input System Functions
  //===--------------------------------------------------------------------===//
 
  if (nameId == ksn::TestPlusArgs) {
    // Slang already checks the arity of `$test$plusargs`.
    assert(numArgs == 1 && "`$test$plusargs` takes 1 argument");
    auto *strLit =
        args[0]->unwrapImplicitConversions().as_if<slang::ast::StringLiteral>();
    if (!strLit)
      return emitError(loc) << "`$test$plusargs` argument must be a string "
                               "literal",
             Value{};
    auto foundTy = moore::IntType::getInt(getContext(), 1);
    return moore::PlusArgsTestBIOp::create(
        builder, loc, foundTy, builder.getStringAttr(strLit->getValue()));
  }
 
  if (nameId == ksn::ValuePlusArgs) {
    // Slang already checks the arity of `$value$plusargs`. The parsed value is
    // written back into the second (lvalue) argument, and the function returns
    // whether a matching plusarg was found.
    assert(numArgs == 2 && "`$value$plusargs` takes 2 arguments");
    auto *strLit =
        args[0]->unwrapImplicitConversions().as_if<slang::ast::StringLiteral>();
    if (!strLit)
      return emitError(loc) << "`$value$plusargs` format must be a string "
                               "literal",
             Value{};
    // Slang emits output arguments as a `<lvalue> = EmptyArgument` assignment;
    // unpack it to recover the lvalue that receives the parsed value.
    const auto *valueArg = args[1];
    if (const auto *assign =
            valueArg->as_if<slang::ast::AssignmentExpression>())
      valueArg = &assign->left();
    auto lvalue = convertLvalueExpression(*valueArg);
    if (!lvalue)
      return {};
    auto resultType = cast<moore::RefType>(lvalue.getType()).getNestedType();
    auto foundTy = moore::IntType::getInt(getContext(), 1);
    auto op = moore::PlusArgsValueBIOp::create(
        builder, loc, foundTy, resultType,
        builder.getStringAttr(strLit->getValue()));
    moore::BlockingAssignOp::create(builder, loc, lvalue, op.getResult());
    return op.getFound();
  }
 
  if (nameId == ksn::FScanf) {
    auto fd = convertRvalueExpression(
        *args[0], moore::IntType::getInt(builder.getContext(), 32));
    if (!fd)
      return {};
    auto *fmtLit =
        args[1]->unwrapImplicitConversions().as_if<slang::ast::StringLiteral>();
    if (!fmtLit)
      return (mlir::emitError(loc)
              << "$fscanf requires a string literal format string"),
             Value{};
    auto cursor =
        moore::ScanBeginFScanFOp::create(builder, loc, fd).getCursor();
    auto result =
        convertScanString(fmtLit->getValue(), cursor, args.subspan(2), loc);
    if (failed(result))
      return {};
    if (failed(emitScanAssignments(*this, *result, loc)))
      return {};
    return moore::ScanEndOp::create(builder, loc, result->finalCursor)
        .getCount();
  }
 
  if (nameId == ksn::SScanf) {
    auto str =
        convertRvalueExpression(*args[0], moore::StringType::get(getContext()));
    if (!str)
      return {};
    auto *fmtLit =
        args[1]->unwrapImplicitConversions().as_if<slang::ast::StringLiteral>();
    if (!fmtLit)
      return (mlir::emitError(loc)
              << "$sscanf requires a string literal format string"),
             Value{};
    auto cursor =
        moore::ScanBeginSScanFOp::create(builder, loc, str).getCursor();
    auto result =
        convertScanString(fmtLit->getValue(), cursor, args.subspan(2), loc);
    if (failed(result))
      return {};
    if (failed(emitScanAssignments(*this, *result, loc)))
      return {};
    return moore::ScanEndOp::create(builder, loc, result->finalCursor)
        .getCount();
  }
 
  //===--------------------------------------------------------------------===//
  // Enum Methods
  //===--------------------------------------------------------------------===//
 
  // `first`, `last`, and `num` are already folded to a constant by Slang.
  assert(!(nameId == ksn::First || nameId == ksn::Last || nameId == ksn::Num) ||
         !args[0]->type->isEnum());
 
  if (nameId == ksn::Name && args[0]->type->isEnum()) {
    assert(numArgs == 1 && "`name` takes 1 argument");
    auto value = convertRvalueExpression(*args[0]);
    if (!value)
      return {};
    auto helper = getOrCreateEnumHelper(*args[0]->type, nameId, loc);
    if (!helper)
      return {};
    return mlir::func::CallOp::create(builder, loc, helper, ValueRange{value})
        .getResult(0);
  }
 
  if ((nameId == ksn::Next || nameId == ksn::Prev) && args[0]->type->isEnum()) {
    assert(numArgs >= 1 && numArgs <= 2 && "`next`/`prev` take 1 or 2 args");
    auto value = convertRvalueExpression(*args[0]);
    if (!value)
      return {};
 
    // The step count defaults to 1 if it is not given explicitly.
    auto posType = moore::IntType::getInt(getContext(), 32);
    Value count;
    if (numArgs == 2)
      count = convertRvalueExpression(*args[1], posType);
    else
      count = moore::ConstantOp::create(builder, loc, posType, 1);
    if (!count)
      return {};
 
    auto helper = getOrCreateEnumHelper(*args[0]->type, nameId, loc);
    if (!helper)
      return {};
    return mlir::func::CallOp::create(builder, loc, helper,
                                      ValueRange{value, count})
        .getResult(0);
  }
 
  // Unrecognized system call
  emitError(loc) << "unsupported system call `" << name << "`";
  return {};
}
 
// Resolve any (possibly nested) SymbolRefAttr to an op from the root.
static mlir::Operation *resolve(Context &context, mlir::SymbolRefAttr sym) {
  return context.symbolTable.lookupNearestSymbolFrom(context.intoModuleOp, sym);
}
 
bool Context::isClassDerivedFrom(const moore::ClassHandleType &actualTy,
                                 const moore::ClassHandleType &baseTy) {
  if (!actualTy || !baseTy)
    return false;
 
  mlir::SymbolRefAttr actualSym = actualTy.getClassSym();
  mlir::SymbolRefAttr baseSym = baseTy.getClassSym();
 
  if (actualSym == baseSym)
    return true;
 
  auto *op = resolve(*this, actualSym);
  auto decl = llvm::dyn_cast_or_null<moore::ClassDeclOp>(op);
  // Walk up the inheritance chain via ClassDeclOp::$base (SymbolRefAttr).
  while (decl) {
    mlir::SymbolRefAttr curBase = decl.getBaseAttr();
    if (!curBase)
      break;
    if (curBase == baseSym)
      return true;
    decl = llvm::dyn_cast_or_null<moore::ClassDeclOp>(resolve(*this, curBase));
  }
  return false;
}
 
moore::ClassHandleType
Context::getAncestorClassWithProperty(const moore::ClassHandleType &actualTy,
                                      llvm::StringRef fieldName, Location loc) {
  // Start at the actual class symbol.
  mlir::SymbolRefAttr classSym = actualTy.getClassSym();
 
  while (classSym) {
    // Resolve the class declaration from the root symbol table owner.
    auto *op = resolve(*this, classSym);
    auto decl = llvm::dyn_cast_or_null<moore::ClassDeclOp>(op);
    if (!decl)
      break;
 
    // Scan the class body for a property with the requested symbol name.
    for (auto &block : decl.getBody()) {
      for (auto &opInBlock : block) {
        if (auto prop =
                llvm::dyn_cast<moore::ClassPropertyDeclOp>(&opInBlock)) {
          if (prop.getSymName() == fieldName) {
            // Found a declaring ancestor: return its handle type.
            return moore::ClassHandleType::get(actualTy.getContext(), classSym);
          }
        }
      }
    }
 
    // Not found here—climb to the base class (if any) and continue.
    classSym = decl.getBaseAttr(); // may be null; loop ends if so
  }
 
  // No ancestor declares that property.
  mlir::emitError(loc) << "unknown property `" << fieldName << "`";
  return {};
}
 
//===--------------------------------------------------------------------===//
// Value Range Expression Methods
//===--------------------------------------------------------------------===//
 
Value Context::convertInsideCheck(Value insideLhs, Location loc,
                                  const slang::ast::Expression &expr) {
  // The value range list on the right-hand side of the inside operator is a
  // comma-separated list of expressions or ranges.
  if (const auto *valueRange = expr.as_if<slang::ast::ValueRangeExpression>()) {
    auto lowBound =
        convertToSimpleBitVector(convertRvalueExpression(valueRange->left()));
    auto highBound =
        convertToSimpleBitVector(convertRvalueExpression(valueRange->right()));
    if (!insideLhs || !lowBound || !highBound)
      return {};
 
    Value rangeLhs, rangeRhs;
    // Determine if the insideLhs on the left-hand side is inclusively
    // within the range.
    if (valueRange->left().type->isSigned() ||
        insideLhs.getType().isSignedInteger()) {
      rangeLhs = moore::SgeOp::create(builder, loc, insideLhs, lowBound);
    } else {
      rangeLhs = moore::UgeOp::create(builder, loc, insideLhs, lowBound);
    }
 
    if (valueRange->right().type->isSigned() ||
        insideLhs.getType().isSignedInteger()) {
      rangeRhs = moore::SleOp::create(builder, loc, insideLhs, highBound);
    } else {
      rangeRhs = moore::UleOp::create(builder, loc, insideLhs, highBound);
    }
 
    return moore::AndOp::create(builder, loc, rangeLhs, rangeRhs);
  }
 
  // Handle expressions.
  if (!expr.type->isIntegral()) {
    if (expr.type->isUnpackedArray()) {
      mlir::emitError(loc,
                      "unpacked arrays in 'inside' expressions not supported");
      return {};
    }
    mlir::emitError(
        loc, "only simple bit vectors supported in 'inside' expressions");
    return {};
  }
 
  auto value = convertToSimpleBitVector(convertRvalueExpression(expr));
  if (!value)
    return {};
  return moore::WildcardEqOp::create(builder, loc, insideLhs, value);
}