Adding the stream.resource.cast op.

We had a potential correctness issue when using chained external fences
and returning values (vs writing to output arguments) where we'd insert
a `stream.async.transfer` as effectively just a cast to external
lifetime for returned tensors. The problem is that the
`stream.timepoint.barrier` feeding the chain_external op was *before*
the transfer, meaning that if the user did wait on the fence and consume
the returned value they may be consuming it *before* the transfer has
executed. We're mostly saved today by most usage being through the
synchronous ABI or torch placing results into outputs as well as most
transfers being elided, but it was not guaranteed.

This adds a `stream.resource.cast` that just does lifetime assertions
and pins values in usage refinement. This allows us to import/export
and cast to avoid any potential for copies to arise. Future changes
will use this op in a timeline verification pass that checks that
resources produced by every StreamableOp are consumed using an
appropriate timeline.

Author: benvanik

compiler/src/iree/compiler/Dialect/Stream/Analysis/ResourceUsage.cpp

@@ -402,6 +402,14 @@ class ValueResourceUsage : public AbstractResourceUsage<DFX::ValueElement> {
               DFX::Resolution::REQUIRED);
           getState() ^= tiedUsage.getState();
         })
+        .Case([&](IREE::Stream::ResourceCastOp op) {
+          // Cast is a tied passthrough - propagate source usage to result.
+          // The result type's lifetime constraints are set during init.
+          auto &sourceUsage = solver.getElementFor<ValueResourceUsage>(
+              *this, Position::forValue(op.getSource()),
+              DFX::Resolution::REQUIRED);
+          getState() ^= sourceUsage.getState();
+        })
         .Case([&](IREE::Stream::AsyncTransferOp op) {
           removeAssumedBits(NOT_TRANSFER_WRITE);
           auto &sourceUsage = solver.getElementFor<ValueResourceUsage>(
@@ -753,6 +761,14 @@ class ValueResourceUsage : public AbstractResourceUsage<DFX::ValueElement> {
               DFX::Resolution::OPTIONAL);
           getState() ^= resultUsage.getState();
         })
+        .Case([&](IREE::Stream::ResourceCastOp op) {
+          // Cast is a tied passthrough - propagate result usage to source.
+          // The source type's lifetime constraints are set during init.
+          auto &resultUsage = solver.getElementFor<ValueResourceUsage>(
+              *this, Position::forValue(op.getResult()),
+              DFX::Resolution::OPTIONAL);
+          getState() ^= resultUsage.getState();
+        })
         .Case([&](IREE::Stream::AsyncTransferOp op) {
           removeAssumedBits(NOT_TRANSFER_READ);
           auto &resultUsage = solver.getElementFor<ValueResourceUsage>(

compiler/src/iree/compiler/Dialect/Stream/Conversion/HALToStream/Patterns.cpp

@@ -84,11 +84,13 @@ struct ConvertTensorImportOp
                      .getResult(0);
     }
 
+    // Cast to unknown lifetime for use in the program.
+    // This is a compile-time assertion that the imported resource shares
+    // storage with the program's view of it. RefineUsage will propagate the
+    // external constraint and the cast will fold when types match.
     auto unknownType = rewriter.getType<IREE::Stream::ResourceType>();
-    Value newImport = IREE::Stream::AsyncTransferOp::create(
-        rewriter, op.getLoc(), unknownType, resource, resultSize, resultSize,
-        /*source_affinity=*/executionAffinityAttr,
-        /*target_affinity=*/executionAffinityAttr);
+    Value newImport = IREE::Stream::ResourceCastOp::create(
+        rewriter, op.getLoc(), unknownType, resource, resultSize);
     rewriter.replaceOpWithMultiple(op, {{newImport, resultSize}});
     return success();
   }
@@ -158,17 +160,17 @@ struct ConvertTensorExportOp
         transferTensorOperands(op.getLoc(), op.getSource(), adaptor.getSource(),
                                executionAffinityAttr, rewriter);
 
-    // Exporting a produced value - transfer our source value to an externally
-    // usable resource and directly export it. This will cause an allocation.
+    // Exporting a produced value - cast to external lifetime assertion.
+    // This is a compile-time assertion that the source resource shares storage
+    // with the exported buffer. RefineUsage will propagate the external
+    // constraint backward and the cast will fold when types match.
     Value exportSource = adaptor.getSource().front();
     auto externalType = rewriter.getType<IREE::Stream::ResourceType>(
         IREE::Stream::Lifetime::External);
     if (source.resource.getType() != externalType) {
-      exportSource = IREE::Stream::AsyncTransferOp::create(
+      exportSource = IREE::Stream::ResourceCastOp::create(
           rewriter, op.getLoc(), externalType, source.resource,
-          source.resourceSize, source.resourceSize,
-          /*source_affinity=*/source.affinity,
-          /*target_affinity=*/executionAffinityAttr);
+          source.resourceSize);
     }
 
     // Export (stream resource to buffer view).

compiler/src/iree/compiler/Dialect/Stream/Conversion/HALToStream/test/abi_ops.mlir

@@ -11,7 +11,7 @@ util.func public @importBufferView(%view: !hal.buffer_view) -> tensor<?x?x4xf32>
   //  CHECK-DAG: %[[SIZE:.+]] = stream.tensor.sizeof tensor<?x?x4xf32>{%[[DIM0]], %[[DIM1]]} : index
   //      CHECK: %[[RESOURCE:.+]] = stream.tensor.import %[[VIEW]] : !hal.buffer_view ->
   // CHECK-SAME:     tensor<?x?x4xf32>{%[[DIM0]], %[[DIM1]]} in !stream.resource<external>{%[[SIZE]]}
-  // CHECK-NEXT: %[[RESULT:.+]] = stream.async.clone %[[RESOURCE]] :
+  // CHECK-NEXT: %[[RESULT:.+]] = stream.resource.cast %[[RESOURCE]] :
   // CHECK-SAME:     !stream.resource<external>{%[[SIZE]]} -> !stream.resource<*>{%[[SIZE]]}
   %0 = hal.tensor.import %view : !hal.buffer_view -> tensor<?x?x4xf32>{%dim0, %dim1}
   // CHECK: util.return %[[RESULT]], %[[SIZE]] : !stream.resource<*>, index
@@ -26,7 +26,7 @@ util.func public @importBufferViewBitcasting(%view: !hal.buffer_view) -> tensor<
   //  CHECK-DAG: %[[SIZE:.+]] = stream.tensor.sizeof tensor<4xbf16>
   //      CHECK: %[[RESOURCE:.+]] = stream.tensor.import %[[VIEW]] : !hal.buffer_view ->
   // CHECK-SAME:     tensor<2xui32> in !stream.resource<external>{%[[SIZE]]}
-  // CHECK-NEXT: %[[RESULT:.+]] = stream.async.clone %[[RESOURCE]] :
+  // CHECK-NEXT: %[[RESULT:.+]] = stream.resource.cast %[[RESOURCE]] :
   // CHECK-SAME:     !stream.resource<external>{%[[SIZE]]} -> !stream.resource<*>{%[[SIZE]]}
   %0 = hal.tensor.import %view : !hal.buffer_view -> tensor<2xui32> as tensor<4xbf16>
   // CHECK: util.return %[[RESULT]], %[[SIZE]] : !stream.resource<*>, index
@@ -45,7 +45,7 @@ util.func public @importBufferViewAsync(%view: !hal.buffer_view, %fence: !hal.fe
   //      CHECK: %[[TIMEPOINT:.+]] = stream.timepoint.import %[[FENCE]]
   //      CHECK: %[[SYNC_RESOURCE:.+]] = stream.timepoint.await %[[TIMEPOINT]] => %[[ASYNC_RESOURCE]]
   // CHECK-SAME:     : !stream.resource<external>{%[[SIZE]]}
-  // CHECK-NEXT: %[[RESULT:.+]] = stream.async.clone %[[SYNC_RESOURCE]]
+  // CHECK-NEXT: %[[RESULT:.+]] = stream.resource.cast %[[SYNC_RESOURCE]]
   // CHECK-SAME:     : !stream.resource<external>{%[[SIZE]]} -> !stream.resource<*>{%[[SIZE]]}
   %0 = hal.tensor.import wait(%fence) => %view : !hal.buffer_view -> tensor<4xf32>
   // CHECK: util.return %[[RESULT]], %[[SIZE]] : !stream.resource<*>, index
@@ -57,7 +57,7 @@ util.func public @importBufferViewAsync(%view: !hal.buffer_view, %fence: !hal.fe
 // CHECK-LABEL: @exportBufferView
 // CHECK-SAME: (%[[TENSOR:.+]]: !stream.resource<*>, %[[SIZE:.+]]: index, %[[DIM0:.+]]: index, %[[DIM1:.+]]: index)
 util.func public @exportBufferView(%tensor: tensor<?x?x4xf32>, %dim0: index, %dim1: index) -> !hal.buffer_view {
-  //      CHECK: %[[VIEW:.+]] = stream.async.clone %[[TENSOR]] :
+  //      CHECK: %[[VIEW:.+]] = stream.resource.cast %[[TENSOR]] :
   // CHECK-SAME:     !stream.resource<*>{%[[SIZE]]} -> !stream.resource<external>{%[[SIZE]]}
   // CHECK-NEXT: %[[RESULT:.+]] = stream.tensor.export %[[VIEW]] :
   // CHECK-SAME:     tensor<?x?x4xf32>{%[[DIM0]], %[[DIM1]]} in !stream.resource<external>{%[[SIZE]]}
@@ -127,7 +127,7 @@ util.func public @importBufferViewCrossDevice(%view: !hal.buffer_view) -> tensor
   //  CHECK-DAG: %[[SIZE:.+]] = stream.tensor.sizeof on(#hal.device.promise<@dev_a>) tensor<4xf32>
   //      CHECK: %[[RESOURCE:.+]] = stream.tensor.import on(#hal.device.promise<@dev_a>) %[[VIEW]] : !hal.buffer_view ->
   // CHECK-SAME:     tensor<4xf32> in !stream.resource<external>{%[[SIZE]]}
-  // CHECK-NEXT: %[[CLONE:.+]] = stream.async.clone on(#hal.device.promise<@dev_a>) %[[RESOURCE]] :
+  // CHECK-NEXT: %[[CLONE:.+]] = stream.resource.cast %[[RESOURCE]] :
   // CHECK-SAME:     !stream.resource<external>{%[[SIZE]]} -> !stream.resource<*>{%[[SIZE]]}
   %0 = hal.tensor.import on(#hal.device.promise<@dev_a>) %view : !hal.buffer_view -> tensor<4xf32>
   // CHECK: util.return %[[CLONE]], %[[SIZE]] : !stream.resource<*>, index
@@ -144,7 +144,7 @@ util.func public @importBufferViewCrossDevice(%view: !hal.buffer_view) -> tensor
 util.func public @exportBufferViewCrossDevice(%tensor: tensor<4xf32>) -> !hal.buffer_view attributes {
   stream.affinity = #hal.device.promise<@dev_a>
 } {
-  //      CHECK: %[[CLONE:.+]] = stream.async.clone %[[TENSOR]] :
+  //      CHECK: %[[CLONE:.+]] = stream.resource.cast %[[TENSOR]] :
   // CHECK-SAME:     !stream.resource<*>{%[[SIZE]]} -> !stream.resource<external>{%[[SIZE]]}
   // CHECK-NEXT: %[[VIEW:.+]] = stream.tensor.export %[[CLONE]] :
   // CHECK-SAME:     tensor<4xf32> in !stream.resource<external>{%[[SIZE]]}

compiler/src/iree/compiler/Dialect/Stream/Conversion/UtilToStream/test/global_ops.mlir

@@ -83,7 +83,7 @@ util.func public @globalStoreFromExternal(%arg0: !hal.buffer_view) {
   %dim0 = hal.buffer_view.dim<%arg0 : !hal.buffer_view>[0] : index
   // CHECK: %[[SIZE:.+]] = stream.tensor.sizeof tensor<?x4xf32>{%[[DIM0]]} : index
   // CHECK: %[[IMPORT:.+]] = stream.tensor.import %arg0 : !hal.buffer_view -> tensor<?x4xf32>{%[[DIM0]]} in !stream.resource<external>{%[[SIZE]]}
-  // CHECK: %[[T:.+]] = stream.async.transfer %[[IMPORT]] : !stream.resource<external>{%[[SIZE]]} -> !stream.resource<*>{%[[SIZE]]}
+  // CHECK: %[[T:.+]] = stream.resource.cast %[[IMPORT]] : !stream.resource<external>{%[[SIZE]]} -> !stream.resource<*>{%[[SIZE]]}
   %0 = hal.tensor.import %arg0 : !hal.buffer_view -> tensor<?x4xf32>{%dim0}
   // CHECK: %[[VAR:.+]] = stream.async.transfer %[[T]] : !stream.resource<*>{%[[SIZE]]} -> !stream.resource<variable>{%[[SIZE]]}
   // CHECK: util.global.store %[[VAR]], @var_with_buffer_view_store : !stream.resource<variable>

compiler/src/iree/compiler/Dialect/Stream/IR/StreamOpFolders.cpp

@@ -1049,6 +1049,80 @@ void ResourceSubviewOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.insert<SinkSubviewAcrossSelectOps>(context);
 }
 
+//===----------------------------------------------------------------------===//
+// stream.resource.cast
+//===----------------------------------------------------------------------===//
+
+OpFoldResult ResourceCastOp::fold(FoldAdaptor operands) {
+  // Fold away cast if source and result types match.
+  if (getSource().getType() == getResult().getType()) {
+    return getSource();
+  }
+  // Fold chain: cast(cast(x)) -> cast(x) when outer result type matches x.
+  if (auto sourceCastOp = getSource().getDefiningOp<ResourceCastOp>()) {
+    if (sourceCastOp.getSource().getType() == getResult().getType()) {
+      return sourceCastOp.getSource();
+    }
+  }
+  return {};
+}
+
+namespace {
+
+// Collapses chains of casts into a single cast to the final type.
+// This handles cases where fold() can't apply because the types don't match.
+struct CollapseResourceCastChain : public OpRewritePattern<ResourceCastOp> {
+  using OpRewritePattern::OpRewritePattern;
+  LogicalResult matchAndRewrite(ResourceCastOp op,
+                                PatternRewriter &rewriter) const override {
+    auto sourceCastOp = op.getSource().getDefiningOp<ResourceCastOp>();
+    if (!sourceCastOp)
+      return failure();
+    // Skip if fold() would apply.
+    if (sourceCastOp.getSource().getType() == op.getResult().getType())
+      return failure();
+    // Replace with single cast from original source to final type.
+    rewriter.replaceOpWithNewOp<ResourceCastOp>(op, op.getResult().getType(),
+                                                sourceCastOp.getSource(),
+                                                sourceCastOp.getSourceSize());
+    return success();
+  }
+};
+
+// Commutes cast through subview: cast(subview(x)) -> subview(cast(x)).
+// This pushes casts earlier to increase folding opportunities.
+struct CommuteCastThroughSubview : public OpRewritePattern<ResourceCastOp> {
+  using OpRewritePattern::OpRewritePattern;
+  LogicalResult matchAndRewrite(ResourceCastOp op,
+                                PatternRewriter &rewriter) const override {
+    auto subviewOp = op.getSource().getDefiningOp<ResourceSubviewOp>();
+    if (!subviewOp)
+      return failure();
+    // Only commute if subview has single use (the cast).
+    if (!subviewOp->hasOneUse())
+      return failure();
+    // Create cast of the subview source with the target lifetime.
+    auto castResultType = op.getResult().getType();
+    auto newCast = ResourceCastOp::create(rewriter, op.getLoc(), castResultType,
+                                          subviewOp.getSource(),
+                                          subviewOp.getSourceSize());
+    // Create new subview with cast result.
+    rewriter.replaceOpWithNewOp<ResourceSubviewOp>(
+        op, castResultType, newCast, subviewOp.getSourceSize(),
+        subviewOp.getSourceOffset(), subviewOp.getResultSize());
+    // Clean up the old subview.
+    rewriter.eraseOp(subviewOp);
+    return success();
+  }
+};
+
+} // namespace
+
+void ResourceCastOp::getCanonicalizationPatterns(RewritePatternSet &results,
+                                                 MLIRContext *context) {
+  results.insert<CollapseResourceCastChain, CommuteCastThroughSubview>(context);
+}
+
 //===----------------------------------------------------------------------===//
 // stream.file.read
 //===----------------------------------------------------------------------===//

compiler/src/iree/compiler/Dialect/Stream/IR/StreamOps.cpp

@@ -1690,6 +1690,30 @@ IREE::Stream::ResourceSubviewOp ResourceSubviewOp::findSubviewOp(Value value) {
   return {};
 }
 
+//===----------------------------------------------------------------------===//
+// stream.resource.cast
+//===----------------------------------------------------------------------===//
+
+Value ResourceCastOp::getTiedResult(unsigned resultIndex) {
+  return IREE::Util::TiedOpInterface::findTiedBaseValue(getSource());
+}
+
+::std::optional<unsigned>
+ResourceCastOp::getTiedResultOperandIndex(unsigned resultIndex) {
+  return {0}; // source
+}
+
+SmallVector<int64_t> ResourceCastOp::getTiedResultOperandIndices() {
+  return {0}; // source
+}
+
+LogicalResult ResourceCastOp::verify() {
+  if (getSourceSize() != getResultSize()) {
+    return emitOpError("source and result sizes must be equal (tied storage)");
+  }
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // stream.resource.transients
 //===----------------------------------------------------------------------===//

compiler/src/iree/compiler/Dialect/Stream/IR/StreamOps.td

@@ -730,6 +730,67 @@ def Stream_ResourceSubviewOp : Stream_PureOp<"resource.subview", [
   let hasFolder = 1;
 }
 
+def Stream_ResourceCastOp : Stream_PureOp<"resource.cast", [
+  DeclareOpInterfaceMethods<Util_TiedOpInterface, [
+    "getTiedResult",
+    "getTiedResultOperandIndex",
+    "getTiedResultOperandIndices",
+  ]>,
+  Util_SizeAwareOp,
+]> {
+  let summary = [{Casts a resource to a different lifetime.}];
+  let description = [{
+    Asserts that a resource has a specific lifetime. This is a compile-time
+    constraint that influences lifetime resolution during RefineUsage. The
+    source and result share the same underlying storage (tied operation).
+
+    This is NOT a StreamableOp - it has no execution semantics and does not
+    participate in timeline verification. It purely constrains type resolution.
+
+    The source and result sizes must be equal (verified at compile time).
+
+    Example:
+    ```mlir
+    // Assert resource must resolve to external lifetime.
+    %1 = stream.resource.cast %0 : !stream.resource<*>{%size} -> !stream.resource<external>{%size}
+    ```
+  }];
+
+  let arguments = (ins
+    Stream_AnyStreamResource:$source,
+    Stream_Size:$source_size,
+    Stream_Size:$result_size
+  );
+  let results = (outs
+    Stream_AnyStreamResource:$result
+  );
+
+  let assemblyFormat = [{
+    $source `:` type($source) `{` $source_size `}`
+    `->` type($result) `{` $result_size `}`
+    attr-dict
+  }];
+
+  let builders = [
+    OpBuilder<(ins
+      "Type":$resultType,
+      "Value":$source,
+      "Value":$size
+    ), [{
+      build($_builder, $_state, resultType, source, size, size);
+    }]>,
+  ];
+
+  let extraClassDeclaration = [{
+    Value getOperandSize(unsigned idx) { return getSourceSize(); }
+    Value getResultSize(unsigned idx) { return getResultSize(); }
+  }];
+
+  let hasVerifier = 1;
+  let hasFolder = 1;
+  let hasCanonicalizer = 1;
+}
+
 def Stream_ResourceTransientsOp : Stream_PureOp<"resource.transients", [
   AllTypesMatch<["resource", "result"]>,
   DeclareOpInterfaceMethods<Stream_AffinityOp, [

compiler/src/iree/compiler/Dialect/Stream/Transforms/RefineUsage.cpp

@@ -500,8 +500,9 @@ static void insertUsageRefinementPatterns(MLIRContext *context,
                   ApplyGenericOp<mlir::scf::ConditionOp>,
                   ApplyGenericOp<mlir::scf::YieldOp>,
                   ApplyGenericOp<IREE::Stream::TimepointAwaitOp>,
-                  ApplyGenericOp<IREE::Stream::TimepointBarrierOp>>(context,
-                                                                    analysis);
+                  ApplyGenericOp<IREE::Stream::TimepointBarrierOp>,
+                  ApplyGenericOp<IREE::Stream::ResourceCastOp>>(context,
+                                                                analysis);
   patterns.insert<ApplyStreamableOp<IREE::Stream::ResourceAllocOp>,
                   ApplyStreamableOp<IREE::Stream::ResourceAllocaOp>,
                   ApplyStreamableOp<IREE::Stream::ResourceTransientsOp>,

compiler/src/iree/compiler/Dialect/Stream/Transforms/test/convert_to_stream.mlir

@@ -32,7 +32,7 @@ util.func public @simple_mul(%arg0: !hal.buffer_view) -> !hal.buffer_view attrib
   // CHECK: hal.buffer_view.assert<%arg0 : !hal.buffer_view> message("tensor") shape([%0, %c4]) type(%[[ELEMENT_TYPE]]) encoding(%[[ENCODING_TYPE]])
   // CHECK: %[[ARG0_SIZE:.+]] = stream.tensor.sizeof tensor<?x4xf32>{%[[DIM0]]} : index
   // CHECK: %[[ARG0_IMPORT:.+]] = stream.tensor.import %arg0 : !hal.buffer_view -> tensor<?x4xf32>{%[[DIM0]]} in !stream.resource<external>{%[[ARG0_SIZE]]}
-  // CHECK: %[[ARG0_T:.+]] = stream.async.transfer %[[ARG0_IMPORT]] : !stream.resource<external>{%[[ARG0_SIZE]]} -> !stream.resource<*>{%[[ARG0_SIZE]]}
+  // CHECK: %[[ARG0_T:.+]] = stream.resource.cast %[[ARG0_IMPORT]] : !stream.resource<external>{%[[ARG0_SIZE]]} -> !stream.resource<*>{%[[ARG0_SIZE]]}
   %0 = hal.tensor.import %arg0 : !hal.buffer_view -> tensor<?x4xf32>{%dim0}
 
   %c1 = arith.constant 1 : index
@@ -41,7 +41,7 @@ util.func public @simple_mul(%arg0: !hal.buffer_view) -> !hal.buffer_view attrib
   // CHECK: %[[RET0:.+]] = stream.tensor.dispatch @executable::@dispatch[%c2, %c1, %c1](%[[ARG0_T]]) : (tensor<?x4xf32>{%[[DIM0]]} in !stream.resource<*>{%[[ARG0_SIZE]]}) -> tensor<?xf32>{%[[DIM0]]} in !stream.resource<*>{%[[RET0_SIZE]]}
   %1 = flow.dispatch @executable::@dispatch[%c2, %c1, %c1](%0) : (tensor<?x4xf32>{%dim0}) -> tensor<?xf32>{%dim0}
 
-  // CHECK: %[[RET0_T:.+]] = stream.async.transfer %[[RET0]] : !stream.resource<*>{%[[RET0_SIZE]]} -> !stream.resource<external>{%[[RET0_SIZE]]}
+  // CHECK: %[[RET0_T:.+]] = stream.resource.cast %[[RET0]] : !stream.resource<*>{%[[RET0_SIZE]]} -> !stream.resource<external>{%[[RET0_SIZE]]}
   // CHECK: %[[RET0_EXPORT:.+]] = stream.tensor.export %[[RET0_T]] : tensor<?xf32>{%[[DIM0]]} in !stream.resource<external>{%[[RET0_SIZE]]} -> !hal.buffer_view
   %2 = hal.tensor.export %1 : tensor<?xf32>{%dim0} -> !hal.buffer_view
   // CHECK: util.return %[[RET0_EXPORT]] : !hal.buffer_view

compiler/src/iree/compiler/Dialect/Stream/Transforms/test/refine_usage.mlir

@@ -554,3 +554,22 @@ util.func public @transients_external_result(%size: index, %storage_size: index)
   // CHECK: util.return {{.+}} !stream.resource<external>
   util.return %awaited : !stream.resource<*>
 }
+
+// -----
+
+// Tests that stream.resource.cast propagates its constraint to the source value.
+// The cast asserts the result must be external, so the source (splat) must also
+// become external. After refinement, the cast folds away since types match.
+
+// CHECK-LABEL: @resourceCastPropagation
+util.func public @resourceCastPropagation(%size: index) -> !stream.resource<external> {
+  %c123_i32 = arith.constant 123 : i32
+  // The splat should be refined to external due to the cast constraint.
+  // CHECK: %[[SPLAT:.+]] = stream.async.splat %c123_i32 {{.+}} -> !stream.resource<external>
+  %splat = stream.async.splat %c123_i32 : i32 -> !stream.resource<*>{%size}
+  // The cast should fold away after the source type is refined to match.
+  // CHECK-NOT: stream.resource.cast
+  %cast = stream.resource.cast %splat : !stream.resource<*>{%size} -> !stream.resource<external>{%size}
+  // CHECK: util.return %[[SPLAT]] : !stream.resource<external>
+  util.return %cast : !stream.resource<external>
+}