Method constructor

packages/hardhat-errors/src/errors.ts:64–121

(
    ...[
      errorDescriptor,
      messageArgumentsOrParentError,
      parentError,
    ]: HardhatErrorConstructorArguments<ErrorDescriptorT>
  )

  readonly #formattedMessage: string;

  constructor(
    ...[
      errorDescriptor,
      messageArgumentsOrParentError,
      parentError,
    ]: HardhatErrorConstructorArguments<ErrorDescriptorT>
  ) {
    const errorCode = getErrorCode(errorDescriptor);

    const formattedMessage =
      messageArgumentsOrParentError === undefined ||
      messageArgumentsOrParentError instanceof Error
        ? errorDescriptor.messageTemplate
        : applyErrorMessageTemplate(
            errorDescriptor.messageTemplate,
            messageArgumentsOrParentError,
          );

    super(
      `${errorCode}: ${formattedMessage}`,
      parentError instanceof Error
        ? parentError
        : messageArgumentsOrParentError instanceof Error
          ? messageArgumentsOrParentError
          : undefined,
    );

    this.#descriptor = errorDescriptor;
    this.#errorCode = errorCode;
    this.#formattedMessage = formattedMessage;

    if (
      messageArgumentsOrParentError === undefined ||
      messageArgumentsOrParentError instanceof Error
    ) {
      /* eslint-disable @typescript-eslint/consistent-type-assertions --
      Typescript inference get's lost here, but we know that if we didn't get
      arguments, it's because the error doesn't have any. */
      this.#arguments = {} as MessageTemplateArguments<
        ErrorDescriptorT["messageTemplate"]
      >;
    } else {
      this.#arguments = messageArgumentsOrParentError;
    }

    // As this package is going to be used from most of our packages, there's a
    // change of users having multiple versions of it. If that happens, they may
    // have multiple `HardhatError` classes, so we can't reliably use
    // `instanceof` to check if an error is a `HardhatError`. We define a
    // pseudo-private field to use it for it. While this is not bulletproof, it
    // should be enough for our case, as we won't be changing this class often.
    Object.defineProperty(this, IS_HARDHAT_ERROR_PROPERTY_NAME, {
      configurable: false,
      enumerable: false,
      writable: false,
      value: true,
    });
  }