diff --git a/lib/rules/no-extra-parens.js b/lib/rules/no-extra-parens.js
index v8.28.0..v8.29.0 100644
--- a/lib/rules/no-extra-parens.js
+++ b/lib/rules/no-extra-parens.js
@@ -53,5 +53,6 @@
                                 enforceForSequenceExpressions: { type: "boolean" },
                                 enforceForNewInMemberExpressions: { type: "boolean" },
-                                enforceForFunctionPrototypeMethods: { type: "boolean" }
+                                enforceForFunctionPrototypeMethods: { type: "boolean" },
+                                allowParensAfterCommentPattern: { type: "string" }
                             },
                             additionalProperties: false
@@ -87,4 +88,5 @@
         const IGNORE_FUNCTION_PROTOTYPE_METHODS = ALL_NODES && context.options[1] &&
             context.options[1].enforceForFunctionPrototypeMethods === false;
+        const ALLOW_PARENS_AFTER_COMMENT_PATTERN = ALL_NODES && context.options[1] && context.options[1].allowParensAfterCommentPattern;
 
         const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" });
@@ -403,4 +405,17 @@
                     return;
                 }
+
+                if (ALLOW_PARENS_AFTER_COMMENT_PATTERN) {
+                    const commentsBeforeLeftParenToken = sourceCode.getCommentsBefore(leftParenToken);
+                    const totalCommentsBeforeLeftParenTokenCount = commentsBeforeLeftParenToken.length;
+                    const ignorePattern = new RegExp(ALLOW_PARENS_AFTER_COMMENT_PATTERN, "u");
+
+                    if (
+                        totalCommentsBeforeLeftParenTokenCount > 0 &&
+                        ignorePattern.test(commentsBeforeLeftParenToken[totalCommentsBeforeLeftParenTokenCount - 1].value)
+                    ) {
+                        return;
+                    }
+                }
             }
 
diff --git a/lib/rules/no-invalid-regexp.js b/lib/rules/no-invalid-regexp.js
index v8.28.0..v8.29.0 100644
--- a/lib/rules/no-invalid-regexp.js
+++ b/lib/rules/no-invalid-regexp.js
@@ -61,4 +61,18 @@
 
         /**
+         * Reports error with the provided message.
+         * @param {ASTNode} node The node holding the invalid RegExp
+         * @param {string} message The message to report.
+         * @returns {void}
+         */
+        function report(node, message) {
+            context.report({
+                node,
+                messageId: "regexMessage",
+                data: { message }
+            });
+        }
+
+        /**
          * Check if node is a string
          * @param {ASTNode} node node to evaluate
@@ -109,8 +123,11 @@
         /**
          * Check syntax error in a given flags.
-         * @param {string} flags The RegExp flags to validate.
+         * @param {string|null} flags The RegExp flags to validate.
          * @returns {string|null} The syntax error.
          */
         function validateRegExpFlags(flags) {
+            if (!flags) {
+                return null;
+            }
             try {
                 validator.validateFlags(flags);
@@ -123,8 +140,8 @@
         return {
             "CallExpression, NewExpression"(node) {
-                if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp" || !isString(node.arguments[0])) {
+                if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp") {
                     return;
                 }
-                const pattern = node.arguments[0].value;
+
                 let flags = getFlags(node);
 
@@ -133,22 +150,27 @@
                 }
 
-                const message =
-                    (
-                        flags && validateRegExpFlags(flags)
-                    ) ||
-                    (
+                let message = validateRegExpFlags(flags);
 
-                        // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
-                        flags === null
-                            ? validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)
-                            : validateRegExpPattern(pattern, flags.includes("u"))
-                    );
+                if (message) {
+                    report(node, message);
+                    return;
+                }
 
+                if (!isString(node.arguments[0])) {
+                    return;
+                }
+
+                const pattern = node.arguments[0].value;
+
+                message = (
+
+                    // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
+                    flags === null
+                        ? validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)
+                        : validateRegExpPattern(pattern, flags.includes("u"))
+                );
+
                 if (message) {
-                    context.report({
-                        node,
-                        messageId: "regexMessage",
-                        data: { message }
-                    });
+                    report(node, message);
                 }
             }
diff --git a/lib/rules/prefer-named-capture-group.js b/lib/rules/prefer-named-capture-group.js
index v8.28.0..v8.29.0 100644
--- a/lib/rules/prefer-named-capture-group.js
+++ b/lib/rules/prefer-named-capture-group.js
@@ -24,4 +24,59 @@
 const parser = new regexpp.RegExpParser();
 
+/**
+ * Creates fixer suggestions for the regex, if statically determinable.
+ * @param {number} groupStart Starting index of the regex group.
+ * @param {string} pattern The regular expression pattern to be checked.
+ * @param {string} rawText Source text of the regexNode.
+ * @param {ASTNode} regexNode AST node which contains the regular expression.
+ * @returns {Array<SuggestionResult>} Fixer suggestions for the regex, if statically determinable.
+ */
+function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
+    switch (regexNode.type) {
+        case "Literal":
+            if (typeof regexNode.value === "string" && rawText.includes("\\")) {
+                return null;
+            }
+            break;
+        case "TemplateLiteral":
+            if (regexNode.expressions.length || rawText.slice(1, -1) !== pattern) {
+                return null;
+            }
+            break;
+        default:
+            return null;
+    }
+
+    const start = regexNode.range[0] + groupStart + 2;
+
+    return [
+        {
+            fix(fixer) {
+                const existingTemps = pattern.match(/temp\d+/gu) || [];
+                const highestTempCount = existingTemps.reduce(
+                    (previous, next) =>
+                        Math.max(previous, Number(next.slice("temp".length))),
+                    0
+                );
+
+                return fixer.insertTextBeforeRange(
+                    [start, start],
+                    `?<temp${highestTempCount + 1}>`
+                );
+            },
+            messageId: "addGroupName"
+        },
+        {
+            fix(fixer) {
+                return fixer.insertTextBeforeRange(
+                    [start, start],
+                    "?:"
+                );
+            },
+            messageId: "addNonCapture"
+        }
+    ];
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -39,7 +94,11 @@
         },
 
+        hasSuggestions: true,
+
         schema: [],
 
         messages: {
+            addGroupName: "Add name to capture group.",
+            addNonCapture: "Convert group to non-capturing.",
             required: "Capture group '{{group}}' should be converted to a named or non-capturing group."
         }
@@ -47,13 +106,15 @@
 
     create(context) {
+        const sourceCode = context.getSourceCode();
 
         /**
          * Function to check regular expression.
-         * @param {string} pattern The regular expression pattern to be check.
-         * @param {ASTNode} node AST node which contains regular expression.
+         * @param {string} pattern The regular expression pattern to be checked.
+         * @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
+         * @param {ASTNode} regexNode AST node which contains the regular expression.
          * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.
          * @returns {void}
          */
-        function checkRegex(pattern, node, uFlag) {
+        function checkRegex(pattern, node, regexNode, uFlag) {
             let ast;
 
@@ -69,4 +130,7 @@
                 onCapturingGroupEnter(group) {
                     if (!group.name) {
+                        const rawText = sourceCode.getText(regexNode);
+                        const suggest = suggestIfPossible(group.start, pattern, rawText, regexNode);
+
                         context.report({
                             node,
@@ -74,5 +138,6 @@
                             data: {
                                 group: group.raw
-                            }
+                            },
+                            suggest
                         });
                     }
@@ -84,5 +149,5 @@
             Literal(node) {
                 if (node.regex) {
-                    checkRegex(node.regex.pattern, node, node.regex.flags.includes("u"));
+                    checkRegex(node.regex.pattern, node, node, node.regex.flags.includes("u"));
                 }
             },
@@ -102,5 +167,5 @@
 
                     if (regex) {
-                        checkRegex(regex, node, flags && flags.includes("u"));
+                        checkRegex(regex, node, node.arguments[0], flags && flags.includes("u"));
                     }
                 }
diff --git a/package.json b/package.json
index v8.28.0..v8.29.0 100644
--- a/package.json
+++ b/package.json
@@ -1,5 +1,5 @@
 {
   "name": "eslint",
-  "version": "8.28.0",
+  "version": "8.29.0",
   "author": "Nicholas C. Zakas <[email protected]>",
   "description": "An AST-based pattern checker for JavaScript.",