- yujuhong
  - derekwaynecarr
  - caesarxuchao
  - mikedanese
  - liggitt
  - sttts
  - dchen1107
  - saad-ali
  - luxas
  - janetkuo
  - justinsb
  - ncdc
  - tallclair
  - jsafrane
  - dims

  virtual Status SetAttrBool(const char* attr_name, bool value) = 0;
  virtual Status SetAttrType(const char* attr_name, DataType value) = 0;
  virtual Status SetAttrShape(const char* attr_name, const int64_t* dims,
                              const int num_dims) = 0;
  virtual Status SetAttrShape(const char* attr_name,
                              const PartialTensorShape shape);
  virtual Status SetAttrFunction(const char* attr_name,

reviewers:
  - thockin
  - smarterclayton
  - wojtek-t
  - deads2k
  - derekwaynecarr
  - caesarxuchao
  - mikedanese
  - liggitt
  - justinsb
  - ncdc
  - dims
  - ingvagabund

  - yujuhong
  - derekwaynecarr
  - caesarxuchao
  - mikedanese
  - liggitt
  - sttts
  - dchen1107
  - saad-ali
  - luxas
  - janetkuo
  - justinsb
  - ncdc
  - tallclair
  - jsafrane
  - dims

  // Note that if shape is unknown rank, shape.dim_sizes() will be empty, and
  // shape.dims() will be -1.
  absl::InlinedVector<int64_t, 4UL> dim_sizes = shape.dim_sizes();
  TF_RETURN_IF_ERROR(varhandle_op->SetAttrShape(
      "shape", reinterpret_cast<const int64_t*>(dim_sizes.data()),
      shape.dims()));
  TF_RETURN_IF_ERROR(varhandle_op->SetAttrString("container", "", 0));
  TF_RETURN_IF_ERROR(

  - liggitt
  - mikedanese
  - pohly
  - SataQiu
  - smarterclayton
  - spiffxp
  - sttts
  - thockin
  - wojtek-t
approvers:
  - bentheelder
  - cblecker
  - dchen1107
  - deads2k
  - dims # for local-up-cluster related files
  - enj # for sig-auth related stuff like cert testdata
  - liggitt
  - mikedanese
  - pohly # for logging and linting
  - pwittrock
  - SataQiu
  - smarterclayton

					} else if len(dims) == 0 {
						count = -1 // As in x[].
					}
				}
				dims = append(dims, count)
			case TagEnumerationType:
				err = DecodeError{name, kid.Offset, "cannot handle enumeration type as array bound"}
				goto Error
			}
		}
		if len(dims) == 0 {
			// LLVM generates this for x[].
			dims = []int64{-1}
		}

		t.Count = dims[0]

  if (num_dims < 0) {
    proto.set_unknown_rank(true);
  } else {
    for (int d = 0; d < num_dims; ++d) {
      proto.add_dim()->set_size(dims[d]);
    }
  }

  forward_op_->attrs.Set(attr_name, proto);
  return op_->SetAttrShape(attr_name, dims, num_dims);
}
Status SetAttrFunction(AbstractOperation* op_, const char* attr_name,
                       const AbstractOperation* value,

  EXPECT_EQ(revived_tensor->Type(), expected.dtype());
  EXPECT_EQ(revived_tensor->NumElements(), expected.NumElements());
  EXPECT_EQ(revived_tensor->NumDims(), expected.dims());
  for (int i = 0; i < expected.dims(); ++i) {
    EXPECT_EQ(revived_tensor->Dim(i), expected.dim_size(i));
  }

  testing::CheckBufferDataIsEqual(expected.dtype(), expected.NumElements(),

  // The default is already unknown
  if (!context->RankKnown(handle)) return absl::OkStatus();

  std::vector<int64_t> dims(context->Rank(handle));
  for (int32_t i = 0, end = dims.size(); i < end; ++i) {
    dims[i] = context->Value(context->Dim(handle, i));
  }
  return PartialTensorShape::MakePartialShape(dims.data(), dims.size(), shape);
}

Status PropagateShapes(Graph* graph,