return true
	}
	return st.Sel.Name == "StringData"
}

// isVariable reports whether x is a variable, possibly with field references.
func (p *Package) isVariable(x ast.Expr) bool {
	switch x := x.(type) {
	case *ast.Ident:
		return true
	case *ast.SelectorExpr:
		return p.isVariable(x.X)
	case *ast.IndexExpr:
		return true
	}
	return false
}

                                  const std::vector<uint8_t>& buffer,
                                  bool is_variable, OpBuilder builder,
                                  Location loc, bool use_stablehlo_constant) {
  if (tensor.sparsity != nullptr) {
    return BuildSparseConstOp(tensor, buffer, builder, loc);
  }

  if (is_variable) {
    return BuildVariableOp(tensor, builder, loc);
  }

            return LogicalResult::failure();
          }

          if (is_variable) {
            input.emitOpError() << "unexpected multiple TPUReplicatedInputOp "
                                << "for single argument";
            return LogicalResult::failure();
          }
          is_variable = true;
        } else {
          is_non_variable = true;
        }
      }

};

void ExpectEqualTensor(TensorT* tensor, TensorT* expected_tensor) {
  const float eps = 1e-7;
  EXPECT_THAT(expected_tensor, NotNull());
  EXPECT_THAT(tensor->is_variable, Eq(expected_tensor->is_variable));
  EXPECT_THAT(tensor->shape, Eq(expected_tensor->shape));
  EXPECT_THAT(tensor->type, Eq(expected_tensor->type));
  const auto quantization_params = tensor->quantization.get();