} else if (callable.getKind() == CallableKindInfo.AFTER_CONSTRUCTOR) {
            generateInvocationAfterConstructor(implTypeField, method, callable, implementationName, implementationDescriptor);
        }
    }

 * limitations under the License.
 */

package org.gradle.kotlin.dsl

import java.util.concurrent.Callable


/**
 * Enables function invocation syntax on [Callable] references.
 * @see Callable.call
 */
operator fun <V> Callable<V>.invoke(): V =

    }

    @Nonnull
    private static List<ParameterMatchEntry> parameterMatchEntries(CallableInfo callable) {
        Optional<ParameterInfo> varargParameter = callable.getParameters().stream().filter(it -> it.getKind() == ParameterKindInfo.VARARG_METHOD_PARAMETER).findAny();
        CallableKindInfo kind = callable.getKind();
        return Stream.of(
            // Match the `Class<?>` in `receiver` for static methods and constructors

                } finally {
                    executing.remove();
                }
            }
        };
    }

    protected <V> Callable<V> trackedCommand(final Callable<V> command) {
        return new Callable<V>() {
            @Override
            public V call() throws Exception {
                executing.set(command);
                try {

            project.getTasks().withType(Ear.class).configureEach(task -> {
                task.dependsOn((Callable<FileCollection>) () ->
                    mainFeature.getSourceSet().getRuntimeClasspath()
                );
                task.from((Callable<FileCollection>) () ->
                    mainFeature.getSourceSet().getOutput()
                );
            });
        });
    }

    }

    @Test
    public void canMapPropertiesUsingCallable() {
        Callable callable = new Callable() {
            public Object call() throws Exception {
                return toList("a");
            }
        };

        conventionAware.map("list1", callable);
        assertThat(conventionAware.getConventionValue(null, "list1", false), equalTo((Object) toList("a")));
    }

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code
   * Callable}.
   *
   * @param callable the callable task
   * @since 10.0
   */
  public static <V extends @Nullable Object> ListenableFutureTask<V> create(Callable<V> callable) {
    return new ListenableFutureTask<>(callable);
  }

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code

    runConcurrentTest(
        numberOfThreads,
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {
            long unused = ticker.read();
            return null;
          }
        });

    assertEquals(incrementByNanos * numberOfThreads, ticker.read());
  }

  /** Runs {@code callable} concurrently {@code numberOfThreads} times. */

    taskDone = false;
    Callable<Integer> task =
        new Callable<Integer>() {
          @Override
          public Integer call() {
            taskDone = true;
            return 6;
          }
        };
    Future<Integer> future =
        TestingExecutors.sameThreadScheduledExecutor().schedule(task, 10000, TimeUnit.MILLISECONDS);
    assertTrue("Should run callable immediately", taskDone);

    taskDone = false;
    Callable<Integer> task =
        new Callable<Integer>() {
          @Override
          public Integer call() {
            taskDone = true;
            return 6;
          }
        };
    Future<Integer> future =
        TestingExecutors.sameThreadScheduledExecutor().schedule(task, 10000, TimeUnit.MILLISECONDS);
    assertTrue("Should run callable immediately", taskDone);