def 'adds Scaladoc test to project for Scala 3'() {
        when:
        project.pluginManager.apply(ScalaPlugin)

        temporaryFolder.createFile('libs/scala3-library_3-3.0.1.jar)')
        project.dependencies.add('implementation', project.files('libs/scala3-library_3-3.0.1.jar)'))

        then:
        def task = project.tasks[ScalaPlugin.SCALA_DOC_TASK_NAME]
        task instanceof ScalaDoc

rootProject.name = 'scala3'...

rootProject.name = "scala3"...

    def "defaults scalaClasspath to inferred Scala compiler dependency"() {
        def scalaCompilerLib = versionNumber.major >= 3 ? "scala3-compiler_3" : "scala-compiler"
        file("build.gradle") << """
            apply plugin: "scala-base"

            sourceSets {
               custom
            }

            ${mavenCentralRepository()}

====

If you want to use Scala 3 instead of the `scala-library` dependency you should add the `scala3-library_3` dependency:

.Declaring a Scala 3 dependency for production code
====
include::sample[dir="snippets/scala/scala3/kotlin",files="build.gradle.kts"]
include::sample[dir="snippets/scala/scala3/groovy",files="build.gradle"]
====

        }
    }

    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;