import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
import org.jetbrains.kotlin.test.services.TestModuleStructure
import org.jetbrains.kotlin.test.services.TestServices

object StandaloneModeConfigurator : StandaloneModeConfiguratorBase() {

    override fun configureTest(builder: TestConfigurationBuilder, disposable: Disposable) {
        sourceConfigurator.configureTest(builder, disposable)

abstract class AbstractBuiltInTypeTest : AbstractTypeTest() {

    override fun configureTest(builder: TestConfigurationBuilder) {
        super.configureTest(builder)
        builder.apply {
            useDirectives(Directives)
        }
    }

    override fun getType(analysisSession: KaSession, ktFile: KtFile, module: KtTestModule, testServices: TestServices): KaType {

absl::StatusOr<mlir::quant::QuantizedType> GetQuantizedType(
    const tflite::TensorT& tensor, mlir::Builder builder,
    bool is_constant = false, mlir::Type storage_type = {});

// Imports float tensor with calibration value into calibrated quantized type.
absl::StatusOr<mlir::quant::QuantizedType> GetCalibratedQuantizedType(
    const tflite::TensorT& tensor, mlir::Builder builder);

absl::StatusOr<mlir::TensorType> GetTensorType(const tflite::TensorT& tensor,

  explicit KernelBuilderFactory(TF_KernelBuilder* builder)
      : builder_(builder) {}
  ::tensorflow::OpKernel* Create(
      ::tensorflow::OpKernelConstruction* context) override {
    if (builder_->compute_function)
      return new ::tensorflow::COpKernel(context, builder_->create_function,
                                         builder_->compute_function,
                                         builder_->delete_function);
    else

    OpBuilder builder(launch);
    auto call_op = builder.create<TF::PartitionedCallOp>(
        module.getLoc(), launch.getResultTypes(), launch.getOperands(),
        SymbolRefAttr::get(builder.getContext(), launch.getFunc()),
        /*config=*/builder.getStringAttr(""),
        /*config_proto=*/builder.getStringAttr(""),
        /*executor_type=*/builder.getStringAttr(""));

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package b

import "./a"

type (
	ABuilder = a.Builder
)

func Bfunc() ABuilder {
	return ABuilder{}

import kotlin.test.assertNotNull

abstract class AbstractReferenceImportAliasTest : AbstractAnalysisApiBasedTest() {
    override fun configureTest(builder: TestConfigurationBuilder) {
        super.configureTest(builder)
        with(builder) {
            useDirectives(Directives)
        }
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {

            sourcePathFor(settings),
            matchesProjectsSourceRoots(withMainSourceSetJavaKotlinIn("buildSrc")))
    }

    @TargetGradleVersion(">=5.4 <7.5")
    @LeaksFileHandles("Kotlin compiler daemon on buildSrc jar")
    @Flaky(because = "https://github.com/gradle/gradle-private/issues/3708")
    def "sourcePath includes buildSrc project dependencies source roots"() {

        given:

import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder

abstract class StandaloneModeConfiguratorBase : AnalysisApiTestConfigurator() {
    override val analyseInDependentSession: Boolean get() = false
    override val frontendKind: FrontendKind get() = FrontendKind.Fir

    override val testPrefix: String
        get() = "standalone.fir"

        // Look for a build scoped builder
        ToolingModelBuilderLookup.Builder builder = buildScopeLookup.maybeLocateForBuildScope(modelName, param, buildState);
        if (builder != null) {
            return new BuildToolingScope(builder);
        }

        // Force configuration of the build and locate builder for default project