import org.gradle.api.artifacts.ArtifactCollection;
import org.gradle.api.artifacts.ArtifactView;
import org.gradle.api.file.FileCollection;
import org.gradle.internal.HasInternalProtocol;

/**
 * The outputs of a graph resolution. All results on this type are lazy. Resolution is only performed
 * when the results are accessed.
 *
 * TODO: This type is intended to be made public in future Gradle versions, in some form.
 */

message DebuggerConfig {
  // Type of quantization debugger. Depending on the type, inputs and outputs
  // are wired differently.
  // NEXT ID: 4
  enum DebuggerType {
    DEBUGGER_TYPE_UNSPECIFIED = 0;
    // DEBUGGER_TYPE_WHOLE_MODEL creates two tf.Savedmodel - unquantized and
    // quantized model with DumpTensor added to outputs of quantizable layers.
    // The DumpTensor dumps entire value of its input to a specified file. When

        val main by getting
        val test by getting
        val performanceTest by creating {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
        }
        performanceTest
    }

    private
    fun Project.addPerformanceTestConfigurationAndDependencies() {

    %5 = stablehlo.constant dense<2.000000e+02> : tensor<1x1xf32>  // Output inverse scale.
    %6 = stablehlo.constant dense<2> : tensor<1x1xi8>  // Output zero point.
    // This uniform_quantize function is expected to output i8 instead of i32.
    %7 = call @uniform_quantize_0(%arg0, %0, %1) : (tensor<1x2xf32>, tensor<1x1xf32>, tensor<1x1xi8>) -> tensor<1x2xi32>

    for (int i = 0; i < context->num_outputs(); ++i) {
      auto& output = outputs[i];
      TF_RETURN_IF_ERROR(
          ShapeHandleToTensorShape(context, context->output(i), &output.shape));

      const auto* handle_shapes_and_types =
          context->output_handle_shapes_and_types(i);
      if (handle_shapes_and_types != nullptr) {
        if (handle_shapes_and_types->size() == 1) {

  return init_func_op
      ->getAttrOfType<StringAttr>(kTfSavedModelInitializerTypeAttr)
      .str();
}

// An initializer function should satisfy the follwing conditions:
// * Its GraphOp should only have control outputs.
// * "tf_saved_model.initializer_type" attribute must exist.
LogicalResult ValidateInitFunc(func::FuncOp init_func_op) {
  GraphOp graph_op = GetGraphOpFromFuncOp(init_func_op);

    @TargetGradleVersion(">=3.0 <4.4")
    def "Non-Java project has default output location"() {
        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        EclipseOutputLocation output = project.getOutputLocation()

        then:
        output.path == 'bin'
    }

    @TargetGradleVersion(">=3.0 <4.4")
    def "Java project has default output location"() {
        setup:

  let summary = "Restores function name from XlaCallModule op.";
}

def QuantizeCompositeFunctionsPass : Pass<"stablehlo-quantize-composite-functions", "ModuleOp"> {
  let summary = "Quantize composite functions with QDQ input / outputs.";
  let options = [
    Option<"enable_per_channel_quantized_weight_",
        "enable-per-channel-quantized-weight",
        "bool", /*default=*/"true",
        "Whether to enable per-channel quantized weights.">,

    }

    def "task input property can consume the mapped output of another task connected via project property with #description"() {
        taskTypeWithInputFileProperty()
        taskTypeWithIntInputProperty()

        buildFile << """
            def output = objects.property(Integer)
            output.with {
                $propertyConfig
            }

    }
  }
  return GetTypeFromTFTensorShape(dims, ranked_ty.getElementType());
}

// Calculates computation output shape and build OutputDescription for each
// output based on static shapes in MLIR module. If an output is a resource
// write, `resource_updates` is populated instead of `outputs` for that output.
Status GetOutputInfo(
    mlir::ModuleOp module, bool use_resource_updates_for_aliases,