%5 = "tf.Identity"(%4) {__op_key = 10: i32, device = "/device:CPU:0"} : (tensor<!tf_type.variant>) -> tensor<!tf_type.variant>
  func.return %5 : tensor<!tf_type.variant>
}
// CHECK-LABEL: __inference_Dataset_map_lambda_160

                typeProjection.projectionKind == Variance.INVARIANT -> {
                    when (typeParameter.variance) {
                        Variance.IN_VARIANCE -> BoundTypeArgument(typeProjection.type, Variance.IN_VARIANCE)
                        Variance.OUT_VARIANCE -> BoundTypeArgument(typeProjection.type, Variance.OUT_VARIANCE)
                        else -> BoundTypeArgument(typeProjection.type, Variance.INVARIANT)
                    }

      // Results in a bad mismatch of shapes.
      %updated_list = "tf.TensorListSetItem"(%list, %index, %element) : (tensor<!tf_type.variant<tensor<64x1xbf16>>>, tensor<i32>, tensor<64x1xbf16>) -> tensor<!tf_type.variant<tensor<64x1xbf16>>>

      return %updated_list : tensor<!tf_type.variant<tensor<64x1xbf16>>>
    }
  })";

  auto compilation_result = CompileMlirModule(
      kTensorListSetItemDimensionTooLarge,

            append((signature.symbol as KaNamedSymbol).name.asString())
            printCollection(signature.valueParameters, prefix = "(", postfix = ")") { parameter ->
                append(parameter.name.asString())
                append(": ")
                append(parameter.returnType.render(position = Variance.INVARIANT))
            }
            append(": ")

            dependsOn(distributionZip)
        }
    }

    // A 'installation' variant providing a folder where the distribution is present in the final format for forked integration testing
    consumableVariant("${name}Installation", "gradle-$name-installation", Bundling.EMBEDDED, emptyList(), installation)

    <test.add.opens></test.add.opens>
    <test.add.args></test.add.args>
    <module.status>integration</module.status>
    <variant.jvmEnvironment>android</variant.jvmEnvironment>
    <variant.jvmEnvironmentVariantName>android</variant.jvmEnvironmentVariantName>
    <otherVariant.version>HEAD-jre-SNAPSHOT</otherVariant.version>
    <otherVariant.jvmEnvironment>standard-jvm</otherVariant.jvmEnvironment>

    <test.add.opens></test.add.opens>
    <test.add.args></test.add.args>
    <module.status>integration</module.status>
    <variant.jvmEnvironment>standard-jvm</variant.jvmEnvironment>
    <variant.jvmEnvironmentVariantName>jre</variant.jvmEnvironmentVariantName>
    <otherVariant.version>HEAD-android-SNAPSHOT</otherVariant.version>
    <otherVariant.jvmEnvironment>android</otherVariant.jvmEnvironment>

        ComponentVariantNodeIdentifier id = new ComponentVariantNodeIdentifier(component.getComponentId(), variant.getName());
        return nodes.computeIfAbsent(id, rci -> {
            NodeState node = new NodeState(idGenerator.nextGraphNodeId(), component, this, variant, selectedByVariantAwareResolution);
            component.addNode(node);

                                PatternRewriter& rewriter) const override {
    Type elementType = getElementTypeOrSelf(op->getResult(0));
    Type newType = nullptr;
    if (auto variant = dyn_cast<TF::VariantType>(elementType)) {
      ArrayRef<TensorType> sub = variant.getSubtypes();
      if (sub.size() == 1) {
        auto inner = sub[0];
        if (!isa<TF::VariantType>(inner)) {
          newType = inner;
        }
      }
    }

                            "Depending on the resolved configuration in this manner",
                        rootNodeName
                    ))
                .withProblemIdDisplayName("Configurations should not act as both a resolution root and a variant simultaneously.")