classes\ that\ are\ not\ assignable\ from\ org.gradle.internal.Factory\ and\ are\ injected\ into\ getters\ via\ @Inject\ or\ are\ injected\ into\ constructors\ via\ @Inject\ should\ be\ annotated\ with\ @ServiceScope=injected-services-should-have-service-scope-applied.txt

import org.jetbrains.kotlin.analysis.api.symbols.KaValueParameterSymbol
import org.jetbrains.kotlin.analysis.api.types.KaSubstitutor

/**
 * A signature of a function-like symbol. This includes functions, getters, setters, lambdas, etc.
 */
public abstract class KaFunctionLikeSignature<out S : KaFunctionLikeSymbol> : KaCallableSignature<S>() {
    /**
     * The use-site-substituted value parameters.
     */

        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal abstract Property<String> getFoo()
                @Internal abstract Property<String> getBar()

                @TaskAction
                void useIt() {
                    assert foo.get() == "foobar"
                }
            }
            tasks.register("mytask", MyTask) {

        val getters = functionsByName
            .filterKeys { it.startsWith("get") && it.substringAfter("get").firstOrNull()?.isUpperCase() == true }
            .mapValues { (_, functions) -> functions.singleOrNull { fn -> fn.parameters.all { it == fn.instanceParameter } } }
            .filterValues { it != null && includeMemberFilter.shouldIncludeMember(it) }
        return getters.mapNotNull { (name, getter) ->

    b.setInsertionPoint(op);
    if (auto dq = llvm::dyn_cast<quantfork::DequantizeCastOp>(op)) {
      auto dcast = b.create<DequantizeOp>(dq.getLoc(), dq.getResult().getType(),
                                          dq.getArg());
      dq.getResult().replaceAllUsesWith(dcast);
      if (auto extra_attr = op->getAttr(mlir::quant::kVolatileOpAttrName)) {
        dcast->setAttr(mlir::quant::kVolatileOpAttrName, extra_attr);
      }
      dq.erase();

    @Override
    ExecHandle build() {
        if (OperatingSystem.current().isWindows()) {
            def theArgs = ['/d', '/c', executable.replace('/', File.separator)] + getArgs()
            setArgs(theArgs) //split purposefully to avoid weird windows CI issue
            executable = 'cmd.exe'
        } else {
            executable = "${workingDir}/${executable}"
        }

    if (!tensor_type) return cast_op.getArg();

    auto attr_names = tensor_type.getAttrKeys();
    if (attr_names.empty() || attr_names.size() > 1) return cast_op.getArg();
    StringRef tfr_type_attr = attr_names[0].getValue();
    if (!fixed_elt_type_attrs_.contains(tfr_type_attr)) return cast_op.getArg();

    Type result_elt_type = GetFixedElementType(tfr_type_attr, rewriter);

      /*is_qdq_conversion=*/false);

  quantization_driver.Initialize();
  ASSERT_TRUE(quantization_driver.PropagateParamsAndReturnIfChanged());
  EXPECT_THAT(quantization_driver.GetArgs(), Not(IsEmpty()));

  for (const auto& arg : quantization_driver.GetArgs()) {
    const QuantState& state = quantization_driver.GetArgQuantState(arg);
    EXPECT_TRUE(isa<quant::QuantizedType>(state.params));
  }

            //
            // Looks like on Windows (MinGW):
            // main T 0000000000401550
            def splits = line.split(' ')
            String name = splits[0]
            char type = splits[1].getChars()[0]
            return new BinaryInfo.Symbol(name, type, Character.isUpperCase(type))
        }
    }

        registerObjectConversionComponent(component)
    }
}


/**
 * Introduces functions for registering dependencies, such as `implementation(...)`, as member functions of
 * types with getters returning [DependencyCollector] in the schema.
 * Resolves such functions at runtime, if used with object conversion.
 */
private
class DependencyCollectorsComponent : AnalysisSchemaComponent, ObjectConversionComponent {