* limitations under the License.
 */
package org.gradle.internal;

import javax.annotation.Nullable;

/**
 * A generic factory which creates instances of type T.
 *
 * @param <T> The type of object created.
 */
public interface Factory<T> {
    /**
     * Creates a new instance of type T.
     * @return The instance.
     */
    @Nullable
    T create();

      throws InvocationTargetException, IllegalAccessException {
    T returnValue = factory.invoke(null, args.toArray());
    if (returnValue == null) {
      Assert.assertTrue(
          factory + " returns null but it's not annotated with @Nullable", isNullable(factory));
    }
    return returnValue;
  }

  /**

      throws InvocationTargetException, IllegalAccessException {
    T returnValue = factory.invoke(null, args.toArray());
    if (returnValue == null) {
      Assert.assertTrue(
          factory + " returns null but it's not annotated with @Nullable", isNullable(factory));
    }
    return returnValue;
  }

  /**

            registerProvider(factory = ::KaFirForLoopInReference)
            registerProvider(factory = ::KaFirInvokeFunctionReference)
            registerProvider(factory = ::KaFirPropertyDelegationMethodsReference)
            registerProvider(factory = ::KaFirDestructuringDeclarationReference)
            registerProvider(factory = ::KaFirArrayAccessReference)
            registerProvider(factory = ::KaFirConstructorDelegationReference)

    suspend fun ReadContext.readConfigurations(componentId: ComponentIdentifier, factory: CalculatedValueContainerFactory): List<LocalConfigurationGraphResolveMetadata> {
        return readList {
            readConfiguration(componentId, factory)
        }
    }

    private
    suspend fun ReadContext.readConfiguration(componentId: ComponentIdentifier, factory: CalculatedValueContainerFactory): LocalConfigurationGraphResolveMetadata {

import org.gradle.internal.Factory;

/**
 * A specialized version of multi cause exception that is cheaper to create
 * because we avoid to fill a stack trace, and the message MUST be generated lazily.
 */
@Contextual
public class DefaultMultiCauseExceptionNoStackTrace extends DefaultMultiCauseException {
    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory) {
        super(messageFactory);

   *       {@link NullPointerException}.
   *   <li>If there is any visible constructor or visible static factory method declared by the
   *       class, all visible instance methods will be checked too using the instance created by
   *       invoking the constructor or static factory method.
   *   <li>If the constructor or factory method used to construct instance takes a parameter that

   *       {@link NullPointerException}.
   *   <li>If there is any visible constructor or visible static factory method declared by the
   *       class, all visible instance methods will be checked too using the instance created by
   *       invoking the constructor or static factory method.
   *   <li>If the constructor or factory method used to construct instance takes a parameter that

    override val factoryName: String
        get() = withValidityAssertion { diagnostic.factory.name }

    override val defaultMessage: String
        get() = withValidityAssertion {
            @Suppress("UNCHECKED_CAST")
            val factory = diagnostic.factory as DiagnosticFactory<UnboundDiagnostic>?
            return factory?.defaultRenderer?.render(diagnostic)

    }

    public DefaultMultiCauseException(Factory<String> messageFactory) {
        this.messageFactory = messageFactory;
    }

    public DefaultMultiCauseException(Factory<String> messageFactory, Throwable... causes) {
        this(messageFactory);
        this.causes.addAll(Arrays.asList(causes));
    }

    public DefaultMultiCauseException(Factory<String> messageFactory, Iterable<? extends Throwable> causes) {