*             このコンストラクタが列挙型に関連している場合
     * @see Constructor#newInstance(Object[])
     */
    public static <T> T newInstance(final Constructor<T> constructor, final Object... args)
            throws InstantiationRuntimeException, IllegalAccessRuntimeException {
        assertArgumentNotNull("constructor", constructor);

        try {
            return constructor.newInstance(args);
        } catch (final InstantiationException e) {

      return method.isVarArgs();
    }
  }

  static class ConstructorInvokable<T> extends Invokable<T, T> {

    final Constructor<?> constructor;

    ConstructorInvokable(Constructor<?> constructor) {
      super(constructor);
      this.constructor = constructor;
    }

    @Override
    final Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[] args)

    }

    /**
     * The actual constructor called by concrete resolve exception implementations. Should not be
     * called except from Gradle internal code.
     *
     * <p>This constructor accepts a dummy parameter since we cannot call the constructor without it,
     * as that emits a deprecation warning. In 9.0, we can change the above constructor to protected
     * and remove this constructor.</p>
     *
     * @since 8.9
     */

    }

    public static class CachedConstructor {
        private final ClassGenerator.GeneratedConstructor<?> constructor;
        private final RuntimeException error;

        private CachedConstructor(ClassGenerator.GeneratedConstructor<?> constructor, RuntimeException error) {
            this.constructor = constructor;
            this.error = error;
        }

        public ClassGenerator.GeneratedConstructor<?> getConstructor() {

        // sorted by the number of parameters the constructor requires
        for (ClassGenerator.GeneratedConstructor<?> constructor : constructors) {
            Class<?>[] parameterTypes = constructor.getParameterTypes();
            // The candidate constructor has fewer parameters than the number of
            // parameters we were given. This can't be the constructor
            if (parameterTypes.length < params.length) {

                .takes(method.getGenericParameterTypes());
    }

    public static MethodDescription of(Constructor<?> constructor) {
        return name("<init>")
                .owner(constructor.getDeclaringClass())
                .takes(constructor.getGenericParameterTypes());
    }

    private String typeName(Type type) {
        if (type == null) {
            return null;
        }

    }

    @Override
    public void add(Method method, String role, String problem) {
        collector.add(method, role, problem);
    }

    @Override
    public void add(Constructor<?> constructor, String problem) {
        collector.add(constructor, problem);
    }

            @Override
            public List<GeneratedConstructor<T>> getConstructors() {
                List<GeneratedConstructor<T>> constructors = new ArrayList<GeneratedConstructor<T>>();
                for (final Constructor<?> constructor : type.getDeclaredConstructors()) {
                    constructors.add(new GeneratedConstructor<T>() {
                        @Override

          .reverse();
  private static final Ordering<Constructor<?>> WITH_STRING_PARAM_THEN_WITH_THROWABLE_PARAM =
      ORDERING_BY_CONSTRUCTOR_PARAMETER_LIST.onResultOf(
          constructor -> asList(constructor.getParameterTypes()));

  @CheckForNull
  private static <X> X newFromConstructor(Constructor<X> constructor, Throwable cause) {
    Class<?>[] paramTypes = constructor.getParameterTypes();

// tag::inject-task-constructor[]
abstract class CustomTask extends DefaultTask {
    private final String message
    private final int number

    @Inject
    CustomTask(String message, int number) {
        this.message = message
        this.number = number
    }
// end::inject-task-constructor[]

    @TaskAction
    void printIt() {
        println("$message $number")
    }
// tag::inject-task-constructor[]
}