return;
    }
    auto element_type = splat_elements_attr.getType().getElementType();
    if (!(element_type.isF32() || element_type.isF16() ||
          element_type.isInteger(1) || element_type.isInteger(32) ||
          element_type.isInteger(64))) {
      return;
    }
    if (splat_elements_attr.getNumElements() *
            splat_elements_attr.getType().getElementTypeBitWidth() <
        kConstantSizeThresholdInBits) {

  CPred<"$0.getType() == $1.getType()">>;

// Checks if the given two values are the same.
def AreTheSameValue : Constraint<
  CPred<"$0 == $1">>;

// Checks if the value has rank.
def HasRank : Constraint<
  CPred<"$0.getType().cast<ShapedType>().hasRank()">>;

// Checks if the value has rank of `n`.
class HasRankOf<int n> : Constraint<
  CPred<"$0.getType().cast<ShapedType>().hasRank() && "

Value AccumulateBuffers(Value a, Value b, OpBuilder builder, Location loc) {
  if (getElementTypeOrSelf(a.getType()) == builder.getI1Type()) {
    return builder.create<TF::LogicalOrOp>(loc, ArrayRef<Type>{a.getType()},
                                           ArrayRef<Value>{a, b});
  }
  return builder.create<TF::AddV2Op>(loc, ArrayRef<Type>{a.getType()},
                                     ArrayRef<Value>{a, b});
}

namespace {

        return InstanceModelView.of(modelNode.getPath(), getType(), instance);
    }

    @Override
    public Optional<String> getValueDescription(MutableModelNode modelNode) {
        Object instance = this.asImmutable(ModelType.untyped(), modelNode, null).getInstance();
        if (instance == null) {
            if (isPrimitiveType(getType())) {
                if (getType().equals(ModelType.of(char.class))) {

  LogicalResult match(stablehlo::SelectOp op) const override {
    if (!IsQuantizedTensorType(op.getOperand(1).getType())) {
      return failure();
    }
    if (!IsQuantizedTensorType(op.getOperand(2).getType())) {
      return failure();
    }
    if (!IsQuantizedTensorType(op.getResult().getType())) {
      return failure();
    }
    return success();
  }

        return new ModelView<M>() {
            private final Map<String, Object> propertyViews = new HashMap<String, Object>();

            @Override
            public ModelPath getPath() {
                return modelNode.getPath();
            }

            @Override
            public ModelType<M> getType() {

  StringAttr conv_padding = op.getPaddingAttr();
  SmallVector<int64_t> padding_nums;
  ShapedType lhs_shape = mlir::cast<ShapedType>(op.getLhs().getType());
  ShapedType rhs_shape = mlir::cast<ShapedType>(op.getRhs().getType());

  // Handle only static shape cases.
  // TODO(b/260284866): Handle dynamic shape cases.
  if (!lhs_shape.hasStaticShape()) {

        ModelType<?> type = reference.getType();
        return "{type: " + (type == null ? null : type.getDisplayName()) + ", path: " + getPath() + ", scope: " + getScope() + ", state: " + getState() + "}";
    }

    @Nullable
    @Override
    public ModelPath getPath() {
        return reference.getPath();
    }

    public ModelType<?> getType() {
        return reference.getType();
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func init() {
	addTestCases(gotypesTests, gotypes)
}

var gotypesTests = []testCase{
	{
		Name: "gotypes.0",
		In: `package main

import "golang.org/x/tools/go/types"
import "golang.org/x/tools/go/exact"

var _ = exact.Kind

func f() {
	_ = exact.MakeBool(true)
}
`,

        if (type.isAssignableFrom(untypedView.getType())) {
            @SuppressWarnings("unchecked") ModelView<T> view = (ModelView<T>) untypedView;
            return view;
        } else {
            // TODO better exception type
            throw new IllegalArgumentException("Model view of type " + untypedView.getType() + " requested as " + type);
        }
    }