abstract class GreetingTask extends DefaultTask {
    // tag::convention-callsites-from-constructor[]
    // setting convention from constructor
    @Input
    abstract Property<String> getGuest()

    GreetingTask() {
        guest.convention("person2")
    }
    // end::convention-callsites-from-constructor[]

    // tag::convention-callsites-from-declaration[]
    // setting convention from declaration

      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CodeFragment
      CONSTRUCTOR visibility:public <> () returnType:<root>.CodeFragment [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
      FUN name:run visibility:public modality:FINAL <> (p0:test.Foo) returnType:kotlin.Unit

    CLASS OBJECT name:Main modality:FINAL visibility:public superTypes:[kotlin.Any]
      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:main.Main
      CONSTRUCTOR visibility:private <> () returnType:main.Main [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

        require(this is SimpleType)
        val declaration = constructor.declarationDescriptor
        return declaration is FunctionClassDescriptor && declaration.functionTypeKind.isSuspendOrKSuspendFunction
    }

    override fun SimpleTypeMarker.isKClass(): Boolean {
        require(this is SimpleType)
        return constructor.declarationDescriptor == builtIns.kClass
    }

        failure.assertHasCause("Could not create task of type 'CustomTask'.")
        failure.assertHasCause("Unable to determine constructor argument #2: missing parameter of type int, or no service of type int")
    }

    def "fails to create custom task if all constructor arguments missing"() {
        given:
        buildFile << CUSTOM_TASK_WITH_CONSTRUCTOR_ARGS
        buildFile << "tasks.register('myTask', CustomTask)"

        val elementType = unwrappedType.constructor.builtIns.getArrayElementType(unwrappedType)
        return KotlinBuiltIns.isArrayOrPrimitiveArray(elementType)
    }

    /** Expanded by default */
    override fun fullyExpandedType(type: KaType): KaType = type

    private fun KotlinType.isDenotable(): Boolean {
        if (this is DefinitelyNotNullType) return false
        return constructor.isDenotable &&

    }
}


/**
 * Base class for the evaluation of a `pluginManagement` block followed by a
 * `buildscript` block followed by a `plugins` block.
 *
 * @constructor Must match the constructor of the [CompiledKotlinBuildscriptAndPluginsBlock] the object!
 */
@ImplicitReceiver(Settings::class)
open class CompiledKotlinSettingsPluginManagementBlock(
    host: KotlinScriptHost<Settings>,

    /**
     * Generates the signature for the given constructor, optionally adding a `name` parameter before all other parameters.
     */
    public static String signature(Constructor<?> constructor, boolean addNameParameter) {
        StringBuilder builder = new StringBuilder();
        visitFormalTypeParameters(constructor.getTypeParameters(), builder);
        visitConstructorParameters(constructor.getGenericParameterTypes(), addNameParameter, builder);

  let dependentDialects = ["TF::TensorFlowDialect"];
  let constructor = "mlir::odml::CreateLegalizeHloToTfPass()";
}

def LegalizeHloToTfLitePass : Pass<"tfl-legalize-hlo", "mlir::ModuleOp"> {
  let summary = "Legalize from MHLO to the TFLite dialect";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
  let constructor = "mlir::odml::CreateLegalizeHloToTfLitePass()";
}

            Constructor<?> constructor = clazz.getConstructor(JUnitPlatformSpec.class, IdGenerator.class, ActorFactory.class, Clock.class);
            return (TestClassProcessor) constructor.newInstance(spec, idGenerator, actorFactory, clock);
        } catch (Exception e) {