#include "tensorflow/compiler/mlir/tensorflow/ir/tf_saved_model.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_types.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_saved_model_passes.h"

#define DEBUG_TYPE "freeze-global-tensor"

namespace mlir {
namespace tf_saved_model {

namespace {

#define GEN_PASS_DEF_FREEZEGLOBALTENSORSPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_savedmodel_passes.h.inc"

import static org.gradle.architecture.test.ArchUnitFixture.freeze;
import static org.gradle.architecture.test.ArchUnitFixture.gradlePublicApi;

@AnalyzeClasses(packages = "org.gradle")
public class KotlinCompatibilityTest {

    @ArchTest
    public static final ArchRule consistent_nullable_annotations_on_public_api = freeze(classes().that(are(gradlePublicApi())).should(haveAccessorsWithSymmetricalNullableAnnotations()));

	if env.Get("_MINIO_DEBUG_NO_EXIT", "") != "" {
		freeze := func(_ int) {
			// Infinite blocking op
			<-make(chan struct{})
		}

		// Override the logger os.Exit()
		logger.ExitFunc = freeze

		defer func() {
			if err := recover(); err != nil {
				fmt.Println("panic:", err)
				fmt.Println("")
				fmt.Println(string(debug.Stack()))
			}
			freeze(-1)
		}()
	}

// RUN: tf-opt "-tf-saved-model-freeze-global-tensors=allow-mutable-tensors=true" -split-input-file %s | FileCheck %s

module attributes {tf_saved_model.semantics} {

  // Test case: Do not fail if the tensor is mutable but allow_mutable_tensors is true

  "tf_saved_model.global_tensor"() { is_mutable, sym_name = "v", type = tensor<f32>, value = dense<1.0> : tensor<f32> } : () -> ()

			return fmt.Errorf("short write emitting stringtab")
		}
	}
	return nil
}

// Freeze sends a signal to the writer that no more additions are
// allowed, only lookups of existing strings (if a lookup triggers
// addition, a panic will result). Useful as a mechanism for
// "finalizing" a string table prior to writing it out.
func (stw *Writer) Freeze() {
	stw.frozen = true
}

        try {
            return delegate.evaluate(classes);
        } catch (RuntimeException e) {
            if (e.getMessage().contains("freeze.store")) {
                throw new RuntimeException("ArchUnit violations changed, please refreeze and check the differences by running ./gradlew architecture-test:test -ParchunitRefreeze", e);
            } else {
                throw e;
            }
        }
    }

import groovy.lang.Closure;
import org.gradle.api.Action;
import org.gradle.api.internal.artifacts.configurations.ConfigurationRole;

import static org.gradle.architecture.test.ArchUnitFixture.freeze;

/**
 * Tests that {@link org.gradle.api.artifacts.Configuration}s are created using the correct factory methods.
 */
@AnalyzeClasses(packages = "org.gradle")
public final class ConfigurationCreationTest {

    llvm::cl::desc("Smuggle disallowed ops via stablehlo.custom_calls."),
    llvm::cl::Optional, llvm::cl::init(true));

// NOLINTNEXTLINE
opt<bool> freeze_tf_graph(
    "freeze-tf-graph",
    llvm::cl::desc("Freeze TF graph to remove tf.ResourceVariable, etc."),
    llvm::cl::Optional, llvm::cl::init(false));

// NOLINTNEXTLINE
opt<std::string> exported_model_signatures(

        this.delegate = delegate;
        this.owner = owner;
    }

    /**
     * Prevent further mutations to this attribute container.
     */
    public void freeze() {
        this.delegate = delegate.asImmutable();
    }

    @Override
    public String toString() {
        return delegate.toString();
    }

    @Override

// RUN: tf-opt -verify-diagnostics -tf-saved-model-freeze-global-tensors -split-input-file %s | FileCheck %s

// CHECK-LABEL: module attributes
module attributes {tf_saved_model.semantics} {

  // Test case: Basic freezing.

  // CHECK-NOT: tf_saved_model.global_tensor
 "tf_saved_model.global_tensor"() {sym_name = "v", type = tensor<f32>, value = dense<1.0> : tensor<f32> } : () -> ()

  // CHECK: func @f()