Bump LLVM to b0b546d44777eb1fa25995384876bd14a006a929. (#7976)

This is not a totally routine bump.

Python support is changing in preparation for a switch to nanobind:

https://discourse.llvm.org/t/psa-python-binding-dependencies-changing/83376

There were also some more DialectConversion changes:

llvm/llvm-project#116470

`InstanceOpConversion`'s 1:1 in FlattenIO generalizes to the 1:N pattern, so we can drop the 1:1 pattern.

Secondly, it seems like the biggest violating thing here is the fact that we were missing a materialization for exploding struct outputs of `hw.module.extern`... This was actually a pretty glaring mistake in the existing IR, which had a check for invalid IR - woops!

Combined with folders, this also seems to have removed some (not all!) of the redundant struct_create/struct_explode patterns in the output.

With the 1:N operand adaptor, we no longer have to manually filter i0 operands inside a conversion pattern. Instead, this information is already implicitly available via the adaptor (i.e. that an operand was removed via. materialization). This also implies that 1:N patterns need to handle the case where the `OneToNOpAdaptor` is empty.

In general, it feels like one would _very_ rarely have to use both the `OneToNOpAdaptor` and `OpAdaptor` overloads at the same time - this should be reserved for when there is truly a difference between 1:1 and 1:N patterns. However, in practice - as this little fixing excercise has demonstrated - most patterns where `OneToNOpAdaptor` is relevant, are generalized 1:N patterns, and doesn't need a specific `1:1` overload.

---------

Co-authored-by: Morten Borup Petersen <[email protected]>

Author: mikeurbach

.github/workflows/nightlyIntegrationTests.yml

@@ -19,7 +19,7 @@ jobs:
     # John and re-run the job.
     runs-on: ["self-hosted", "1ES.Pool=1ES-CIRCT-builds", "linux"]
     container:
-      image: ghcr.io/circt/images/circt-integration-test:v18.0
+      image: ghcr.io/circt/images/circt-integration-test:v18.1
       volumes:
         - /mnt:/__w/circt
     strategy:

.github/workflows/shortIntegrationTests.yml

@@ -29,7 +29,7 @@ jobs:
     # John and re-run the job.
     runs-on: ["self-hosted", "1ES.Pool=1ES-CIRCT-builds", "linux"]
     container:
-      image: ghcr.io/circt/images/circt-integration-test:v18.0
+      image: ghcr.io/circt/images/circt-integration-test:v18.1
       volumes:
         - /mnt:/__w/circt
     strategy:

CMakeLists.txt

@@ -513,8 +513,12 @@ option(CIRCT_BINDINGS_PYTHON_ENABLED "Enables CIRCT Python bindings." OFF)
 
 if(CIRCT_BINDINGS_PYTHON_ENABLED)
   message(STATUS "CIRCT Python bindings are enabled.")
-  include(MLIRDetectPythonEnv)
-  mlir_configure_python_dev_packages()
+  set(MLIR_DISABLE_CONFIGURE_PYTHON_DEV_PACKAGES 0)
+  mlir_detect_pybind11_install()
+  # Prime the search like mlir_configure_python_dev_modules
+  find_package(Python3 3.8 COMPONENTS Interpreter Development)
+  find_package(Python3 3.8 COMPONENTS Interpreter Development.Module)
+  find_package(pybind11 2.10 CONFIG REQUIRED)
 else()
   message(STATUS "CIRCT Python bindings are disabled.")
   # Lookup python either way as some integration tests use python without the

lib/Conversion/ExportVerilog/PruneZeroValuedLogic.cpp

@@ -33,6 +33,14 @@ static bool noI0TypedValue(ValueRange values) {
   return noI0Type(values.getTypes());
 }
 
+/// Flatten the given value ranges into a single vector of values.
+static SmallVector<Value> flattenValues(ArrayRef<ValueRange> values) {
+  SmallVector<Value> result;
+  for (const auto &vals : values)
+    llvm::append_range(result, vals);
+  return result;
+}
+
 namespace {
 
 class PruneTypeConverter : public mlir::TypeConverter {
@@ -51,11 +59,17 @@ struct NoI0OperandsConversionPattern : public OpConversionPattern<TOp> {
 public:
   using OpConversionPattern<TOp>::OpConversionPattern;
   using OpAdaptor = typename OpConversionPattern<TOp>::OpAdaptor;
+  using OneToNOpAdaptor = typename OpConversionPattern<TOp>::OneToNOpAdaptor;
 
   LogicalResult
-  matchAndRewrite(TOp op, OpAdaptor adaptor,
+  matchAndRewrite(TOp op, OneToNOpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    if (noI0TypedValue(adaptor.getOperands()))
+    ValueRange flattenedOperands = flattenValues(adaptor.getOperands());
+
+    // flattenedOperands may be empty (in case all operands are i0 typed and
+    // have already been pruned. Then the 1:N adaptor will reflect this as no
+    // operands).
+    if (!flattenedOperands.empty() && noI0TypedValue(flattenedOperands))
       return failure();
 
     // Part of i0-typed logic - prune it!
@@ -76,6 +90,8 @@ struct NoI0OperandsConversionPattern<comb::ICmpOp>
 public:
   using OpConversionPattern<comb::ICmpOp>::OpConversionPattern;
   using OpAdaptor = typename OpConversionPattern<comb::ICmpOp>::OpAdaptor;
+  using OneToNOpAdaptor =
+      typename OpConversionPattern<comb::ICmpOp>::OneToNOpAdaptor;
 
   // Returns the result of applying the predicate when the LHS and RHS are the
   // exact same value.
@@ -103,9 +119,9 @@ struct NoI0OperandsConversionPattern<comb::ICmpOp>
   }
 
   LogicalResult
-  matchAndRewrite(comb::ICmpOp op, OpAdaptor adaptor,
+  matchAndRewrite(comb::ICmpOp op, OneToNOpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    if (noI0TypedValue(adaptor.getOperands()))
+    if (noI0TypedValue(flattenValues(adaptor.getOperands())))
       return failure();
 
     // Caluculate the result of i0 value comparison.
@@ -123,11 +139,14 @@ struct NoI0OperandsConversionPattern<comb::ParityOp>
 public:
   using OpConversionPattern<comb::ParityOp>::OpConversionPattern;
   using OpAdaptor = typename OpConversionPattern<comb::ParityOp>::OpAdaptor;
+  using OneToNOpAdaptor =
+      typename OpConversionPattern<comb::ParityOp>::OneToNOpAdaptor;
 
   LogicalResult
-  matchAndRewrite(comb::ParityOp op, OpAdaptor adaptor,
+  matchAndRewrite(comb::ParityOp op, OneToNOpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    if (noI0TypedValue(adaptor.getOperands()))
+    ValueRange flattenedOperands = flattenValues(adaptor.getOperands());
+    if (!flattenedOperands.empty() && noI0TypedValue(flattenedOperands))
       return failure();
 
     // The value of "comb.parity i0" is 0.
@@ -143,9 +162,11 @@ struct NoI0OperandsConversionPattern<comb::ConcatOp>
 public:
   using OpConversionPattern<comb::ConcatOp>::OpConversionPattern;
   using OpAdaptor = typename OpConversionPattern<comb::ConcatOp>::OpAdaptor;
+  using OneToNOpAdaptor =
+      typename OpConversionPattern<comb::ConcatOp>::OneToNOpAdaptor;
 
   LogicalResult
-  matchAndRewrite(comb::ConcatOp op, OpAdaptor adaptor,
+  matchAndRewrite(comb::ConcatOp op, OneToNOpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Replace an i0 value with i0 constant.
     if (op.getType().isInteger(0)) {
@@ -154,14 +175,18 @@ struct NoI0OperandsConversionPattern<comb::ConcatOp>
       return success();
     }
 
-    if (noI0TypedValue(adaptor.getOperands()))
+    SmallVector<Value> materializedOperands =
+        flattenValues(adaptor.getOperands());
+
+    // If the materializedOperands are the same as the original operands, then
+    // there were no i0 operands. If not, then that means that this op used to
+    // have an i0 operand but materialization removed that operand, as reflect
+    // in the 1:N operand adaptor.
+    if (materializedOperands.size() == adaptor.getOperands().size())
       return failure();
 
-    // Filter i0 operands and create a new concat op.
-    SmallVector<Value> newOperands;
-    llvm::copy_if(op.getOperands(), std::back_inserter(newOperands),
-                  [](auto op) { return !op.getType().isInteger(0); });
-    rewriter.replaceOpWithNewOp<comb::ConcatOp>(op, newOperands);
+    // Create a new concat op with the materialized operands.
+    rewriter.replaceOpWithNewOp<comb::ConcatOp>(op, materializedOperands);
     return success();
   }
 };
@@ -184,10 +209,10 @@ template <typename TOp>
 struct NoI0ResultsConversionPattern : public OpConversionPattern<TOp> {
 public:
   using OpConversionPattern<TOp>::OpConversionPattern;
-  using OpAdaptor = typename OpConversionPattern<TOp>::OpAdaptor;
+  using OneToNOpAdaptor = typename OpConversionPattern<TOp>::OneToNOpAdaptor;
 
   LogicalResult
-  matchAndRewrite(TOp op, OpAdaptor adaptor,
+  matchAndRewrite(TOp op, OneToNOpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (noI0TypedValue(op->getResults()))
       return failure();

lib/Dialect/HW/Transforms/FlattenIO.cpp

@@ -46,6 +46,14 @@ static llvm::SmallVector<Type> getInnerTypes(hw::StructType t) {
 
 namespace {
 
+/// Flatten the given value ranges into a single vector of values.
+static SmallVector<Value> flattenValues(ArrayRef<ValueRange> values) {
+  SmallVector<Value> result;
+  for (const auto &vals : values)
+    llvm::append_range(result, vals);
+  return result;
+}
+
 // Replaces an output op with a new output with flattened (exploded) structs.
 struct OutputOpConversion : public OpConversionPattern<hw::OutputOp> {
   OutputOpConversion(TypeConverter &typeConverter, MLIRContext *context,
@@ -74,6 +82,29 @@ struct OutputOpConversion : public OpConversionPattern<hw::OutputOp> {
     rewriter.replaceOpWithNewOp<hw::OutputOp>(op, convOperands);
     return success();
   }
+
+  LogicalResult
+  matchAndRewrite(hw::OutputOp op, OneToNOpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    llvm::SmallVector<Value> convOperands;
+
+    // Flatten the operands.
+    for (auto operand : flattenValues(adaptor.getOperands())) {
+      if (auto structType = getStructType(operand.getType())) {
+        auto explodedStruct = rewriter.create<hw::StructExplodeOp>(
+            op.getLoc(), getInnerTypes(structType), operand);
+        llvm::copy(explodedStruct.getResults(),
+                   std::back_inserter(convOperands));
+      } else {
+        convOperands.push_back(operand);
+      }
+    }
+
+    // And replace.
+    opVisited->insert(op->getParentOp());
+    rewriter.replaceOpWithNewOp<hw::OutputOp>(op, convOperands);
+    return success();
+  }
   DenseSet<Operation *> *opVisited;
 };
 
@@ -85,7 +116,7 @@ struct InstanceOpConversion : public OpConversionPattern<hw::InstanceOp> {
         externModules(externModules) {}
 
   LogicalResult
-  matchAndRewrite(hw::InstanceOp op, OpAdaptor adaptor,
+  matchAndRewrite(hw::InstanceOp op, OneToNOpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto referencedMod = op.getReferencedModuleNameAttr();
     // If externModules is populated and this is an extern module instance,
@@ -96,7 +127,7 @@ struct InstanceOpConversion : public OpConversionPattern<hw::InstanceOp> {
     auto loc = op.getLoc();
     // Flatten the operands.
     llvm::SmallVector<Value> convOperands;
-    for (auto operand : adaptor.getOperands()) {
+    for (auto operand : flattenValues(adaptor.getOperands())) {
       if (auto structType = getStructType(operand.getType())) {
         auto explodedStruct = rewriter.create<hw::StructExplodeOp>(
             loc, getInnerTypes(structType), operand);
@@ -176,6 +207,16 @@ class FlattenIOTypeConverter : public TypeConverter {
       return success();
     });
 
+    // Materialize !hw.struct<a,b,...> to a, b, ... via. hw.explode. This
+    // situation may occur in case of hw.extern_module's with struct outputs.
+    addTargetMaterialization([](OpBuilder &builder, TypeRange resultTypes,
+                                ValueRange inputs, Location loc) {
+      if (inputs.size() != 1 && !isStructType(inputs[0].getType()))
+        return ValueRange();
+
+      auto explodeOp = builder.create<hw::StructExplodeOp>(loc, inputs[0]);
+      return ValueRange(explodeOp.getResults());
+    });
     addTargetMaterialization([](OpBuilder &builder, hw::StructType type,
                                 ValueRange inputs, Location loc) {
       auto result = builder.create<hw::StructCreateOp>(loc, type, inputs);
@@ -397,9 +438,12 @@ static LogicalResult flattenOpsOfType(ModuleOp module, bool recursive,
     target.addDynamicallyLegalOp<hw::InstanceOp>([&](hw::InstanceOp op) {
       auto refName = op.getReferencedModuleName();
       return externModules.contains(refName) ||
-             llvm::none_of(op->getOperands(), [](auto operand) {
-               return isStructType(operand.getType());
-             });
+             (llvm::none_of(op->getOperands(),
+                            [](auto operand) {
+                              return isStructType(operand.getType());
+                            }) &&
+              llvm::none_of(op->getResultTypes(),
+                            [](auto result) { return isStructType(result); }));
     });
 
     DenseMap<Operation *, ArrayAttr> oldArgNames, oldResNames;
@@ -498,7 +542,7 @@ class FlattenIOPass : public circt::hw::impl::FlattenIOBase<FlattenIOPass> {
   void runOnOperation() override {
     ModuleOp module = getOperation();
     if (!flattenExtern) {
-      // Record the extern modules, donot flatten them.
+      // Record the extern modules, do not flatten them.
       for (auto m : module.getOps<hw::HWModuleExternOp>())
         externModules.insert(m.getModuleName());
       if (flattenIO<hw::HWModuleOp, hw::HWModuleGeneratedOp>(

llvm

@@ -11,22 +11,18 @@ hw.module @level0(in %arg0 : i32, out out0 : i32) {
 }
 
 // BASIC-LABEL: hw.module @level1(in %arg0 : i32, in %in.a : i1, in %in.b : i2, in %arg1 : i32, out out0 : i32, out out.a : i1, out out.b : i2, out out1 : i32) {
-// BASIC-NEXT:    %0 = hw.struct_create (%in.a, %in.b) : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:    %a, %b = hw.struct_explode %0 : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:    hw.output %arg0, %a, %b, %arg1 : i32, i1, i2, i32
+// BASIC-NEXT:    hw.output %arg0, %in.a, %in.b, %arg1 : i32, i1, i2, i32
 // BASIC-NEXT:  }
 !Struct1 = !hw.struct<a: i1, b: i2>
 hw.module @level1(in %arg0 : i32, in %in : !Struct1, in %arg1: i32, out out0 : i32, out out: !Struct1, out out1: i32) {
     hw.output %arg0, %in, %arg1 : i32, !Struct1, i32
 }
 
 // BASIC-LABEL: hw.module @level2(in %in.aa.a : i1, in %in.aa.b : i2, in %in.bb.a : i1, in %in.bb.b : i2, out out.aa.a : i1, out out.aa.b : i2, out out.bb.a : i1, out out.bb.b : i2) {
-// BASIC-NEXT:    %[[v1:.+]] = hw.struct_create (%in.bb.a, %in.bb.b) : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:    %[[v0:.+]] = hw.struct_create (%in.aa.a, %in.aa.b) : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:    %[[v2:.+]] = hw.struct_create (%[[v0]], %[[v1]]) : !hw.struct<aa: !hw.struct<a: i1, b: i2>, bb: !hw.struct<a: i1, b: i2>>
-// BASIC-NEXT:    %aa, %bb = hw.struct_explode %[[v2]] : !hw.struct<aa: !hw.struct<a: i1, b: i2>, bb: !hw.struct<a: i1, b: i2>>
-// BASIC-NEXT:    %a, %b = hw.struct_explode %aa : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:    %a_0, %b_1 = hw.struct_explode %bb : !hw.struct<a: i1, b: i2>
+// BASIC-NEXT:    %0 = hw.struct_create (%in.bb.a, %in.bb.b) : !hw.struct<a: i1, b: i2>
+// BASIC-NEXT:    %1 = hw.struct_create (%in.aa.a, %in.aa.b) : !hw.struct<a: i1, b: i2>
+// BASIC-NEXT:    %a, %b = hw.struct_explode %1 : !hw.struct<a: i1, b: i2>
+// BASIC-NEXT:    %a_0, %b_1 = hw.struct_explode %0 : !hw.struct<a: i1, b: i2>
 // BASIC-NEXT:    hw.output %a, %b, %a_0, %b_1 : i1, i2, i1, i2
 // BASIC-NEXT:  }
 !Struct2 = !hw.struct<aa: !Struct1, bb: !Struct1>
@@ -40,30 +36,26 @@ hw.type_scope @foo {
 !ScopedStruct = !hw.typealias<@foo::@bar, !Struct1>
 
 // BASIC-LABEL: hw.module @scoped(in %arg0 : i32, in %in.a : i1, in %in.b : i2, in %arg1 : i32, out out0 : i32, out out.a : i1, out out.b : i2, out out1 : i32) {
-// BASIC-NEXT:    %0 = hw.struct_create (%in.a, %in.b) : !hw.typealias<@foo::@bar, !hw.struct<a: i1, b: i2>>
-// BASIC-NEXT:    %a, %b = hw.struct_explode %0 : !hw.typealias<@foo::@bar, !hw.struct<a: i1, b: i2>>
-// BASIC-NEXT:    hw.output %arg0, %a, %b, %arg1 : i32, i1, i2, i32
+// BASIC-NEXT:    hw.output %arg0, %in.a, %in.b, %arg1 : i32, i1, i2, i32
 // BASIC-NEXT:  }
 hw.module @scoped(in %arg0 : i32, in %in : !ScopedStruct, in %arg1: i32, out out0 : i32, out out: !ScopedStruct, out out1: i32) {
   hw.output %arg0, %in, %arg1 : i32, !ScopedStruct, i32
 }
 
 // BASIC-LABEL: hw.module @instance(in %arg0 : i32, in %arg1.a : i1, in %arg1.b : i2, out out.a : i1, out out.b : i2) {
-// BASIC-NEXT:   %0 = hw.struct_create (%arg1.a, %arg1.b) : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:   %a, %b = hw.struct_explode %0 : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:   %l1.out0, %l1.out.a, %l1.out.b, %l1.out1 = hw.instance "l1" @level1(arg0: %arg0: i32, in.a: %a: i1, in.b: %b: i2, arg1: %arg0: i32) -> (out0: i32, out.a: i1, out.b: i2, out1: i32)
-// BASIC-NEXT:   %1 = hw.struct_create (%l1.out.a, %l1.out.b) : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:   %a_0, %b_1 = hw.struct_explode %1 : !hw.struct<a: i1, b: i2>
-// BASIC-NEXT:   hw.output %a_0, %b_1 : i1, i2
+// BASIC-NEXT:    %l1.out0, %l1.out.a, %l1.out.b, %l1.out1 = hw.instance "l1" @level1(arg0: %arg0: i32, in.a: %arg1.a: i1, in.b: %arg1.b: i2, arg1: %arg0: i32) -> (out0: i32, out.a: i1, out.b: i2, out1: i32)
+// BASIC-NEXT:    %0 = hw.struct_create (%l1.out.a, %l1.out.b) : !hw.struct<a: i1, b: i2>
+// BASIC-NEXT:    %a, %b = hw.struct_explode %0 : !hw.struct<a: i1, b: i2>
+// BASIC-NEXT:    hw.output %a, %b : i1, i2
 // BASIC-NEXT: }
 hw.module @instance(in %arg0 : i32, in %arg1 : !Struct1, out out : !Struct1) {
   %0:3 = hw.instance "l1" @level1(arg0: %arg0 : i32, in: %arg1 : !Struct1, arg1: %arg0 : i32) -> (out0: i32, out: !Struct1, out1: i32)
   hw.output %0#1 : !Struct1
 }
 
-hw.module.extern @level1_extern2(out out1: i32, in %arg0 : i32, out out: !Struct1, in %in : !Struct1, in %arg1: i32, out out0 : i32 )
 // EXTERN-LABEL:  hw.module.extern @level1_extern2
 // EXTERN-SAME: out out1 : i32, in %arg0 : i32, out out_a : i1, out out_b : i2, in %in_a : i1, in %in_b : i2, in %arg1 : i32, out out0 : i32
+hw.module.extern @level1_extern2(out out1: i32, in %arg0 : i32, out out: !Struct1, in %in : !Struct1, in %arg1: i32, out out0 : i32 )
 
 hw.module @instance_extern2(in %arg0 : i32, in %arg1 : !Struct1, out out : !Struct1) {
   %0:3 = hw.instance "l1" @level1_extern(arg0: %arg0 : i32, in: %arg1 : !Struct1, arg1: %arg0 : i32) -> (out0: i32, out: !Struct1, out1: i32)
@@ -76,14 +68,12 @@ hw.module @instance_extern2(in %arg0 : i32, in %arg1 : !Struct1, out out : !Stru
 hw.module.extern @level1_extern(in %arg0 : i32, in %in : !Struct1, in %arg1: i32, out out0 : i32, out out: !Struct1, out out1: i32)
 
 
-// EXTERN-LABEL: hw.module @instance_extern(in %arg0 : i32, in %arg1_a : i1, in %arg1_b : i2, out out_a : i1, out out_b : i2) {
-// EXTERN-NEXT:   %0 = hw.struct_create (%arg1_a, %arg1_b) : !hw.struct<a: i1, b: i2>
-// EXTERN-NEXT:   %a, %b = hw.struct_explode %0 : !hw.struct<a: i1, b: i2>
-// EXTERN-NEXT:   %l1.out0, %l1.out_a, %l1.out_b, %l1.out1 = hw.instance "l1" @level1_extern(arg0: %arg0: i32, in_a: %a: i1, in_b: %b: i2, arg1: %arg0: i32) -> (out0: i32, out_a: i1, out_b: i2, out1: i32)
-// EXTERN-NEXT:   %1 = hw.struct_create (%l1.out_a, %l1.out_b) : !hw.struct<a: i1, b: i2>
-// EXTERN-NEXT:   %a_0, %b_1 = hw.struct_explode %1 : !hw.struct<a: i1, b: i2>
-// EXTERN-NEXT:   hw.output %a_0, %b_1 : i1, i2
-
+// EXTERN-LABEL:  hw.module @instance_extern(in %arg0 : i32, in %arg1_a : i1, in %arg1_b : i2, out out_a : i1, out out_b : i2) {
+// EXTERN-NEXT:    %l1.out0, %l1.out_a, %l1.out_b, %l1.out1 = hw.instance "l1" @level1_extern(arg0: %arg0: i32, in_a: %arg1_a: i1, in_b: %arg1_b: i2, arg1: %arg0: i32) -> (out0: i32, out_a: i1, out_b: i2, out1: i32)
+// EXTERN-NEXT:    %0 = hw.struct_create (%l1.out_a, %l1.out_b) : !hw.struct<a: i1, b: i2>
+// EXTERN-NEXT:    %a, %b = hw.struct_explode %0 : !hw.struct<a: i1, b: i2>
+// EXTERN-NEXT:    hw.output %a, %b : i1, i2
+// EXTERN-NEXT:  }
 hw.module @instance_extern(in %arg0 : i32, in %arg1 : !Struct1, out out : !Struct1) {
   %0:3 = hw.instance "l1" @level1_extern(arg0: %arg0 : i32, in: %arg1 : !Struct1, arg1: %arg0 : i32) -> (out0: i32, out: !Struct1, out1: i32)
   hw.output %0#1 : !Struct1

test/Dialect/HW/flatten-io.mlir

@@ -460,7 +460,7 @@ func.func @func_range_no_smt_type(%arg0: !smt.func<(!smt.bool) !smt.func<(!smt.b
 // -----
 
 func.func @func_range_no_smt_type(%arg0: !smt.func<(!smt.bool) !smt.bool>) {
-  // expected-error @below {{0 operands present, but expected 1}}
+  // expected-error @below {{got 0 operands and 1 types}}
   smt.apply_func %arg0() : !smt.func<(!smt.bool) !smt.bool>
   return
 }