final List<T> value

        TypedProviderOfList(Class<T> type, List<T> value) {
            this.type = type
            this.value = value
        }

        @Override
        Class<T> getElementType() {
            return type
        }

        @Override
        protected Value<List<T>> calculateOwnValue(ValueConsumer consumer) {
            return Value.of(value)
        }

      elemType.isInteger(64))
    return true;

  // Complex<F<32>> is allowed.
  if (mlir::isa<ComplexType>(elemType) &&
      mlir::cast<ComplexType>(elemType).getElementType().isF32())
    return true;

  // QUINT8 and UI8 are allowed.
  if (mlir::isa<TF::Quint8Type>(elemType) ||
      (elemType.isInteger(8) && mlir::cast<IntegerType>(elemType).isUnsigned()))
    return true;

  for (int64_t i = 0; i < permutation_array.size(); ++i) {
    transposed_shape[i] = input_type.getDimSize(permutation_array[i]);
  }
  auto transposed_type =
      RankedTensorType::get(transposed_shape, input_type.getElementType());
  return transposed_type;
}

// Returns shape of a ranked tensor.
// Precondition: output_val's is ranked tensor.
// Returns a truncated shape when `truncate` is set to true.

  Type attribute_type = builder.getI64Type();
  return builder.create<TF::StridedSliceOp>(
      loc,
      RankedTensorType::get(
          {}, mlir::cast<ShapedType>(shape_value.getType()).getElementType()),
      /*input=*/shape_value,
      /*begin=*/Create1DConstValue<int32_t>(builder, loc, {dim}),
      /*end=*/Create1DConstValue<int32_t>(builder, loc, {dim + 1}),

        }
        return element;
    }

    Element<T> cachingElement(CollectionProviderInternal<T, ? extends Iterable<T>> provider) {
        final Element<T> element = new Element<>(provider.getElementType(), new ElementsFromCollectionProvider<>(provider), this::doAddRealized);
        if (provider instanceof ChangingValue) {

      // dimension with size 1.
      output_shape[i] = 1;
    } else {
      output_shape[i] = *shape_itr;
      shape_itr++;
    }
  }

  return RankedTensorType::get(output_shape, tensor_type.getElementType());
}

// Determines the output type of the `SliceOp` when it is being inserted in
// place of a `XlaGatherOp`. When the dimensions of `xla_gather_op_output_type`

  for (int i = 0, e = rank; i != e; i++) {
    int64_t dim0 = a.getDimSize(i);
    int64_t dim1 = b.getDimSize(i);
    dims[i] = (dim0 == ShapedType::kDynamic) ? dim1 : dim0;
  }
  return RankedTensorType::get(dims, a.getElementType());
}
}  // namespace detail

// Verifies that op has the same operand and result element types (or type
// itself, if scalar) after resolving reference types (i.e., after converting

Type ToLegalType(Type type) {
  if (IsTFQintType(type)) return GetIntTypeFromTFQint(type);
  if (auto shaped = mlir::dyn_cast<ShapedType>(type)) {
    Type elem = shaped.getElementType();
    if (IsTFQintType(elem)) return shaped.clone(ToLegalType(elem));
  }
  return type;
}

bool IsQintToIntCast(Operation *op) {
  auto cast_op = llvm::dyn_cast<TF::CastOp>(op);

    }

    // Only the composite functions with f32 inputs are quantizable.
    if (call_op.getResults().size() == 1 &&
        !mlir::cast<ShapedType>(call_op->getResult(0).getType())
             .getElementType()
             .isF32()) {
      check_status.Update(absl::InternalError(
          "Composite functions for quantization should be f32 type."));
    }

def CreateTFReadVariableOp : NativeCodeCall<
    "$_builder.create<TF::ReadVariableOp>("
    "  $0.getLoc(),"
    "  GetResourceSubtypeOrDefault("
    "    $2, $1.getType().cast<TensorType>().getElementType()),"
    "  $2)"
    >;

def CheckHasResourceSubtype : Constraint<CPred<"HasResourceSubtype($0)">>;

def CreateConstBoolAttrFalse : NativeCodeCall<"$_builder.getBoolAttr(false)">;