/* VSX scalar FP-integer conversion */
	{as: AXSCVDPSXDS, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-integer conversion, xx2-form */

	/* VSX scalar integer-FP conversion */
	{as: AXSCVSXDDP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar integer-fp conversion, xx2-form */

	/* VSX vector FP-integer conversion */

^bb0(%arg0: tensor<*xf32>, %arg1: tensor<*xf32>):
  %shape1 = arith.constant dense<100.> : tensor<2xf32>
  // expected-error @+1 {{must be tensor of 32/64-bit signed integer values}}
  %r1 = "tf.Reshape" (%arg0, %shape1) : (tensor<*xf32>, tensor<2xf32>) -> tensor<100x100xf32>
  func.return %r1 : tensor<100x100xf32>
}

// -----
// tf.Reshape with incorrect element number.

public String cycleToString(); public String getMessage(); } org/codehaus/plexus/util/dag/CycleDetector.class package org.codehaus.plexus.util.dag; public synchronized class CycleDetector { private static final Integer NOT_VISTITED; private static final Integer VISITING; private static final Integer VISITED; public void CycleDetector(); public static java.util.List hasCycle(DAG); public static java.util.List introducesCycle(Vertex, java.util.Map); public static java.util.List introducesCycle(Vertex); private...

// SplitOp
//===----------------------------------------------------------------------===//

// Extracts and returns the signed integer constant in a 0-rank integer tensor
// or 1-element 1-rank integer tensor if 'value' is a constant.
static std::optional<int64_t> ExtractConstantIntFromTensor(Value value) {
  ElementsAttr attr;
  if (!matchPattern(value, m_Constant(&attr))) return {};

     * <pre>
     * message: {item} is numeric value out of bounds (&lt;{integer} digits&gt;.&lt;{fraction} digits&gt; expected).
     * </pre>
     * @param property The property name for the message. (NotNull)
     * @param fraction The parameter fraction for message. (NotNull)
     * @param integer The parameter integer for message. (NotNull)
     * @return this. (NotNull)
     */

			completions:   6,
			wantTotal:     0,
			wantError:     errors.New(`cannot convert string to integer for index: ""`),
		},
		"invalid due to ending with '-'": {
			indexesString: "0,1-",
			completions:   6,
			wantTotal:     0,
			wantError:     errors.New(`cannot convert string to integer for index: ""`),
		},
		"invalid due to repeated '-'": {
			indexesString: "0,1--3",
			completions:   6,

      slice_op.getEndMask() != 0 || slice_op.getNewAxisMask() != 0 ||
      slice_op.getShrinkAxisMask() != 1)
    return {};

  // Returns a value if the `value` is defined by a ConstOp with a single
  // integer element in it and has an expected rank.
  auto get_const_int = [](Value value,
                          int expected_rank) -> std::optional<int64_t> {
    auto const_op = dyn_cast_or_null<ConstOp>(value.getDefiningOp());

                    property('output')
                        .forbiddenAt(reserved)
                        .includeLink()
                }))
                verifyAll(receivedProblem(index as Integer)) {
                    fqid == 'validation:property-validation:cannot-write-to-reserved-location'
                    contextualLabel == "Property \'output\' points to \'${reserved.absolutePath}\' which is managed by Gradle"

                              << input_element_type << ".\n");
      return failure();
    }

    // Output type of `UniformQuantizeOp` is guaranteed to be a quantized
    // tensor with integer storage type.
    const auto output_storage_type = GetElementType(op.getResult())
                                         .cast<QuantizedType>()
                                         .getStorageType()

func.func private @max_unpooling_2d_filter_wrong_type(%arg0: tensor<1x1x2x1xf32>, %arg1: tensor<1x1x2x1xi32>) -> tensor<1x2x4x1xf32> attributes {tf._implements = #tf_type.func<@"addons:MaxUnpooling2D", {padding = "SAME", pool_size = ["a", "b"], strides = [2, 2]}>}

  // expected-warning @+1 {{'strides' attribute for MaxUnpooling2D does not contain integer values}}