code: function verifyForAlways(context, prevNode, nextNode, paddingLines) {
      if (paddingLines.length > 0) {
          return;
      }
  
      context.report({
          node: nextNode,
          message: "Expected blank line before this statement.",
          fix(fixer) {
              const sourceCode = context.getSourceCode();
              let prevToken = getActualLastToken(sourceCode, prevNode);
              const nextToken = sourceCode.getFirstTokenBetween(
                  prevToken,
                  nextNode,
                  {
                      includeComments: true,
  
                      /**
                       * Skip the trailing comments of the previous node.
                       * This inserts a blank line after the last trailing comment.
                       *
                       * For example:
                       *
                       *     foo(); // trailing comment.
                       *     // comment.
                       *     bar();
                       *
                       * Get fixed to:
                       *
                       *     foo(); // trailing comment.
                       *
                       *     // comment.
                       *     bar();
                       *
                       * @param {Token} token The token to check.
                       * @returns {boolean} `true` if the token is not a trailing comment.
                       * @private
                       */
                      filter(token) {
                          if (astUtils.isTokenOnSameLine(prevToken, token)) {
                              prevToken = token;
                              return false;
                          }
                          return true;
                      }
                  }
              ) || nextNode;
              const insertText = astUtils.isTokenOnSameLine(prevToken, nextToken)
                  ? "\n\n"
                  : "\n";
  
              return fixer.insertTextAfter(prevToken, insertText);
          }
      });
  }
docs: Check and report statements for `always` configuration.
  This autofix inserts a blank line between the given 2 statements.
  If the `prevNode` has trailing comments, it inserts a blank line after the
  trailing comments.
  
  @param {RuleContext} context The rule context to report.
  @param {ASTNode} prevNode The previous node to check.
  @param {ASTNode} nextNode The next node to check.
  @param {Array<Token[]>} paddingLines The array of token pairs that blank
  lines exist between the pair.
  @returns {void}
  @private