private
    fun newConstructorForSerialization(beanType: Class<*>, constructor: Constructor<*>): Constructor<out Any> =
        ReflectionFactory.getReflectionFactory().newConstructorForSerialization(beanType, constructor)

    public static <R> Binding<R> to(Key<R> originalKey, TupleConstructorN<R> constructor, Class<?>[] types) {
        return Binding.to(
                originalKey, constructor, Stream.of(types).map(Key::of).toArray(Key<?>[]::new));
    }

    public static <R> Binding<R> to(Key<R> originalKey, TupleConstructorN<R> constructor, Key<?>[] dependencies) {
        return to(originalKey, constructor, dependencies, 0);
    }

    public static <R> Binding<R> to(

     * @param constructor
     *            コンストラクタ。{@literal null}であってはいけません
     */
    public ConstructorDescImpl(final BeanDesc beanDesc, final Constructor<?> constructor) {
        assertArgumentNotNull("beanDesc", beanDesc);
        assertArgumentNotNull("constructor", constructor);

        this.beanDesc = beanDesc;
        this.constructor = constructor;

    def "creates instance that has default constructor"() {
        when:
        def result = instantiator.newInstance(HasDefaultConstructor)

        then:
        result instanceof HasDefaultConstructor
    }

    def "injects provided parameters into constructor"() {
        when:
        def result = instantiator.newInstance(HasInjectConstructor, "string", 12)

      legalization.
  }];
  let constructor = "CreateAnalyzeVariablesPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
}

def DefaultQuantParamsPass : Pass<"tfl-default-quant", "mlir::func::FuncOp"> {
  let summary = "Apply quantization with default quantization parameter";
  let constructor = "CreateDefaultQuantParamsPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];

    public final void publicFinalMethod() {}

    void notAnnotatedMethod() {}

    static Invokable<A, A> constructor() throws Exception {
      Constructor<A> constructor = A.class.getDeclaredConstructor(Object.class);
      Invokable<A, A> invokable = Invokable.from(constructor);
      assertEquals(constructor.getName(), invokable.getName());
      assertEquals(A.class, invokable.getDeclaringClass());
      return invokable;
    }

    public final void publicFinalMethod() {}

    void notAnnotatedMethod() {}

    static Invokable<A, A> constructor() throws Exception {
      Constructor<A> constructor = A.class.getDeclaredConstructor(Object.class);
      Invokable<A, A> invokable = Invokable.from(constructor);
      assertEquals(constructor.getName(), invokable.getName());
      assertEquals(A.class, invokable.getDeclaringClass());
      return invokable;
    }

            Constructor<? extends T> constructor = generatedClass.getConstructor(GeneratedViewState.class, TypeConverter.class);
            return constructor.newInstance(state, null);
        } catch (InvocationTargetException e) {
            throw UncheckedException.throwAsUncheckedException(e.getTargetException());

    public static <T> Binding<T> bindingFromConstructor(Key<T> key, Constructor<T> constructor) {
        constructor.setAccessible(true);

        Key<?>[] dependencies = toDependencies(key.getType(), constructor);

        Binding<T> binding = Binding.to(
                key,
                args -> {
                    try {
                        return constructor.newInstance(args);

     *             このコンストラクタが列挙型に関連している場合
     * @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) {