*     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *
   * @deprecated Prefer {@linkplain UncheckedExecutionException(String, Throwable)} a constructor

import java.util.HashMap;
import java.util.Map;

public class GuidesContributeIncludeProcessor extends IncludeProcessor {
    private static final String CONTRIBUTE = "contribute";

    // Even though these are unused, these constructors are necessary to prevent
    // "(ArgumentError) asciidoctor: FAILED: Failed to load AsciiDoc document - wrong number of arguments (1 for 0)"
    // See https://github.com/asciidoctor/asciidoctorj/issues/451#issuecomment-210914940

      }
    }
  }

  private fun registerTest(
    access: Feature.BeforeAnalysisAccess,
    java: Class<*>,
  ) {
    access.registerAsUsed(java)
    RuntimeReflection.register(java)
    java.constructors.forEach {
      RuntimeReflection.register(it)
    }
    java.declaredMethods.forEach {
      RuntimeReflection.register(it)
    }
    java.declaredFields.forEach {
      RuntimeReflection.register(it)

        val compilationConfigClass = kotlinScriptAnnotation.compilationConfiguration
        val compilationConfigConstructor = compilationConfigClass.java.constructors.single().apply {
            isAccessible = true
        }
        val compilationConfig = compilationConfigConstructor.newInstance() as ScriptCompilationConfiguration

        factories.add(factory);
      }
    }
    if (!Modifier.isAbstract(type.getRawType().getModifiers())) {
      for (Constructor<?> constructor : type.getRawType().getDeclaredConstructors()) {
        Invokable<T, T> invokable = type.constructor(constructor);
        if (!invokable.isPrivate() && !invokable.isSynthetic()) {
          factories.add(invokable);
        }
      }
    }

   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */
  @Deprecated
  protected ExecutionError() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *
   * @deprecated Prefer {@linkplain ExecutionError(String, Error)} a constructor that accepts a

// pattern. `tf.VarHandleOp` and `tf.Const` are removed unless they are used by
// other ops.
struct RemoveVariableAssignmentByConst
    : public OpRewritePattern<TF::AssignVariableOp> {
  // Inherit the constructors.
  using OpRewritePattern<TF::AssignVariableOp>::OpRewritePattern;

  LogicalResult match(TF::AssignVariableOp assign_op) const override {
    Value resource_operand = assign_op.getOperand(0);

    private final String roleHint;

    @Inject
    private ArtifactFactory artifactFactory;

    private ConflictResolver conflictResolver;

    @Inject
    protected PlexusContainer container;

    // constructors -----------------------------------------------------------

    public AbstractConflictResolverTest(String roleHint) throws Exception {
        this.roleHint = roleHint;
    }

        if (kClass == typeToExtend) softwareTypeImplementations.map(SoftwareTypeInfo<*>::schemaFunction) else emptyList()

    override fun constructors(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<DataConstructor> = emptyList()

    override fun topLevelFunction(function: KFunction<*>, preIndex: DataSchemaBuilder.PreIndex) = null
}

        CallableKindInfo kind = callable.getKind();
        return Stream.of(
            // Match the `Class<?>` in `receiver` for static methods and constructors
            kind == STATIC_METHOD || kind == AFTER_CONSTRUCTOR
                ? Stream.of(new ParameterMatchEntry(callable.getOwner().getType(), RECEIVER_AS_CLASS))
                : Stream.<ParameterMatchEntry>empty(),