try {
                Constructor<Throwable> constructor;
                if (message == null && cause == null) {
                    constructor = (Constructor<Throwable>) typeToken.getRawType().getDeclaredConstructor();
                    return constructor.newInstance();
                } else if (message == null) {
                    constructor = (Constructor<Throwable>) typeToken.getRawType()

      $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 <> () returnType:kotlin.Unit
        EXPRESSION_BODY

   */
  public void testConstructors(Class<?> c, Visibility minimalVisibility) {
    for (Constructor<?> constructor : c.getDeclaredConstructors()) {
      if (minimalVisibility.isVisible(constructor) && !isIgnored(constructor)) {
        testConstructor(constructor);
      }
    }
  }

  /** Runs {@link #testConstructor} on every public constructor in class {@code c}. */
  public void testAllPublicConstructors(Class<?> c) {

        myProperty.set("Hello, Gradle!")
        println(myProperty.get())
    }
}
// end::object-factory[]

// tag::object-factory-inject[]
abstract class MyObjectFactoryTask
@Inject constructor(private var objectFactory: ObjectFactory) : DefaultTask() {

    @TaskAction
    fun doTaskAction() {
        val outputDirectory = objectFactory.directoryProperty()

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

    Option<"prefer_tf2xla_", "prefer-tf2xla", "bool",
        /*default=*/"false",
        "Prioritize tf2xla fallback legalization over MLIR legalization "
        "patterns">,
  ];

  let constructor = "mlir::mhlo::createLegalizeTFPass()";
  let dependentDialects = [
    "arith::ArithDialect",
    "chlo::ChloDialect",
    "func::FuncDialect",
    "mhlo::MhloDialect",
    "quant::QuantizationDialect",

      $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

        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
    }

        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 &&

        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)"