// Occasionally there can be no other version of scala supported by this JDK
        Assume.assumeNotNull(otherVersion)
        return otherVersion
    }

    def getDocsPath() {
        return classes.isScala3() ? "build/docs/scaladoc/_empty_" : "build/docs/scaladoc"
    }

    def setup() {
        classes.scalaVersion = version.toString()
    }

    def "scaladoc produces output"() {
        classes.baseline()

        def scalaLibs = [
            'scala3-compiler_3-3.0.1.', 'scala3-sbt-bridge-3.0.1.', 'scala3-interfaces-3.0.1.', 'tasty-core_3-3.0.1.',
            'scala3-library_3-3.0.1.', 'scala-asm-9.1.0-scala-1', 'compiler-interface-1.3.5', 'jline-reader-3.19.0.',

        }
    }

    def useCompilerPluginIfDefined() {
        // https://docs.scala-lang.org/scala3/guides/migration/plugin-kind-projector.html
        Assume.assumeTrue(
            VersionNumber.parse("2.12.14") <= versionNumber && versionNumber < VersionNumber.parse("2.13.0") ||

	return t.IsInterface() && len(t.AllMethods()) == 0
}

// IsScalar reports whether 't' is a scalar Go type, e.g.
// bool/int/float/complex. Note that struct and array types consisting
// of a single scalar element are not considered scalar, likewise
// pointer types are also not considered scalar.
func (t *Type) IsScalar() bool {
	switch t.kind {
	case TBOOL, TINT8, TUINT8, TINT16, TUINT16, TINT32,

    if (mlir::isa<quant::UniformQuantizedPerAxisType>(element_type)) {
      return false;
    }
    if (IsScalar(value)) {
      return false;
    }
    return elements_attr->isSplat();
  }

  // If this type is a scalar shaped type.
  bool IsScalar(mlir::Value value) const {
    auto type = mlir::dyn_cast<ShapedType>(value.getType());
    if (!type) {
      return false;
    }

    tensorflow::Tensor tensor;
    if (!tensorflow::ConvertToTensor(proto_attr, &tensor).ok())
      return failure();
    if (tensor.dtype() != tensorflow::DT_VARIANT) return failure();
    if (!tensorflow::TensorShapeUtils::IsScalar(tensor.shape()))
      return failure();

    const tensorflow::TensorList *list =
        tensor.scalar<tensorflow::Variant>()().get<tensorflow::TensorList>();
    if (!list) return failure();

  if (!const_input) {
    return false;
  }

  const TensorProto* proto = nullptr;
  if (!TryGetNodeAttr(const_input->def(), "value", &proto)) {
    return false;
  }

  return TensorShapeUtils::IsScalar(proto->tensor_shape());
}

Status MarkForCompilationPassImpl::RunEdgeContractionLoop() {
  TF_RET_CHECK(initialized_ && !edges_contracted_ && !clusters_created_);
  edges_contracted_ = true;

    `TensorShapeUtils` since TensorFlow is scalar strict within Google (for
    example, the shape argument to `tf.reshape` can't be a scalar anymore). The
    open source release was already scalar strict, so outside Google `IsScalar`
    and `IsVector` are exact replacements.
*   The following files are being removed from `tensorflow/core/public/`:
    *   `env.h` -> `../platform/env.h`
    *   `status.h` -> `../lib/core/status.h`