// General convolution (`feature_group_count` = 1)
//   * Permutates given filter to `[o, 0, 1, i]` format.
// Using TransposeOp doesn't work because the quantized dimension
// changes which violates the constraint for the TransposeOp that the
// input's and output's element type should be the same.
DenseIntElementsAttr TransposeFilterInConvolution(
    Location loc, PatternRewriter& rewriter,

                                        elements.getType().getElementType());
  return elements.reshape(new_type);
}

// This assumes that the bias is of shape NxCx1x1 and doesn't require transpose
// Its corresponding constraint is optimize_patterns.td:IsBiasShape()
ElementsAttr ReshapeNCHWBiasToNHWC(Value v, Attribute a) {
  auto elements = mlir::cast<DenseElementsAttr>(a);
  auto shape = mlir::cast<ShapedType>(v.getType()).getShape();

    as its predecessor. This is because the weight of cut edges is always
    minimized when the `Split` is with its predecessor. This colocation
    constraint will be used by the placer graph optimization to assign a device
    to the op.

    This pass should run in the export pipeline after tf-replicate-to-island so

    /** The key of the message: {item} must be in the future. */
    public static final String CONSTRAINTS_Future_MESSAGE = "{constraints.Future.message}";

    /** The key of the message: {item} must be less than or equal to {value}. */
    public static final String CONSTRAINTS_Max_MESSAGE = "{constraints.Max.message}";

    /** The key of the message: {item} must be greater than or equal to {value}. */

  }

  if (auto host_compute_op = dyn_cast<XlaHostComputeOp>(op)) {
    return InferShapeForFunctionAttachedToXlaHostCompute(host_compute_op);
  }

  // TODO(jpienaar): Extract function input arg constraint interface.
  // TODO(jpienaar): Unify the shape propagation to functions using interface.
  if (auto map_dataset_op = dyn_cast<MapDatasetOp>(op)) {
    // TODO(jpienaar): The output type of these ops need to be refined.

   * penalty of applying the batches is spread across threads so that the amortized cost is slightly
   * higher than performing just the operation without enforcing the capacity constraint.
   *
   * This implementation uses a per-segment queue to record a memento of the additions, removals,
   * and accesses that were performed on the map. The queue is drained on writes and when it exceeds

   * penalty of applying the batches is spread across threads so that the amortized cost is slightly
   * higher than performing just the operation without enforcing the capacity constraint.
   *
   * This implementation uses a per-segment queue to record a memento of the additions, removals,
   * and accesses that were performed on the map. The queue is drained on writes and when it exceeds

    "io.k8s.api.core.v1.VolumeNodeAffinity": {
      "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.",
      "properties": {
        "required": {
          "$ref": "#/definitions/io.k8s.api.core.v1.NodeSelector",
          "description": "Required specifies hard node constraints that must be met."
        }
      },
      "type": "object"
    },

FieldName     = identifier .
Element       = Expression | LiteralValue .
</pre>

<p>
The LiteralType's underlying type must be a struct, array, slice, or map type
(the grammar enforces this constraint except when the type is given
as a TypeName).
The types of the elements and keys must be <a href="#Assignability">assignable</a>
to the respective field, element, and key types of the literal type;

	IgnoredGoFiles    []string `json:",omitempty"` // .go source files ignored due to build constraints
	InvalidGoFiles    []string `json:",omitempty"` // .go source files with detected problems (parse error, wrong package name, and so on)
	IgnoredOtherFiles []string `json:",omitempty"` // non-.go source files ignored due to build constraints
	CFiles            []string `json:",omitempty"` // .c source files