Remove unnecessary comments from source code

This simplifies the code by removing redundant inline comments that just
repeat what the code is doing.

Author: Rel1cx

packages/plugins/eslint-plugin-react-x/src/rules/jsx-key-before-spread.ts

@@ -33,16 +33,12 @@ export default createRule<[], MessageID>({
 export function create(context: RuleContext<MessageID, []>): RuleListener {
   return {
     JSXOpeningElement(node) {
-      // Find the index of the first spread prop
       let firstSpreadPropIndex: null | number = null;
       for (const [index, prop] of node.attributes.entries()) {
-        // Check if the prop is a spread prop
         if (prop.type === T.JSXSpreadAttribute) {
-          // Store the index of the first spread prop found
           firstSpreadPropIndex ??= index;
           continue;
         }
-        // If no spread prop has been found yet, continue to the next prop
         if (firstSpreadPropIndex == null) {
           continue;
         }

packages/plugins/eslint-plugin-react-x/src/rules/jsx-no-comment-textnodes.ts

@@ -32,27 +32,22 @@ export default createRule<[], MessageID>({
 });
 
 export function create(context: RuleContext<MessageID, []>): RuleListener {
-  // Checks if a JSX text node or a literal appears to be a comment
   function hasCommentLike(node: TSESTree.JSXText | TSESTree.Literal) {
     // If the node is within a JSX attribute or expression container, it's not a text node comment
     if (AST.isOneOf([T.JSXAttribute, T.JSXExpressionContainer])(node.parent)) {
       return false;
     }
     // Examines the node's raw text to see if it starts with '//' or '/*'
-    const rawValue = context.sourceCode.getText(node);
-    return /^\s*\/(?:\/|\*)/mu.test(rawValue);
+    return /^\s*\/(?:\/|\*)/mu.test(context.sourceCode.getText(node));
   }
-  // This function serves as the visitor for both JSXText and Literal nodes
   const visitorFunction = (node: TSESTree.JSXText | TSESTree.Literal): void => {
     // Ensures the node is a direct child of a JSX element or fragment
     if (!AST.isOneOf([T.JSXElement, T.JSXFragment])(node.parent)) {
       return;
     }
-    // Skips nodes that do not appear to be comments
     if (!hasCommentLike(node)) {
       return;
     }
-    // Reports an issue if a comment-like text node is found
     context.report({
       messageId: "jsxNoCommentTextnodes",
       node,

packages/plugins/eslint-plugin-react-x/src/rules/jsx-shorthand-fragment.ts

@@ -53,7 +53,6 @@ export default createRule<Options, MessageID>({
 export function create(context: RuleContext<MessageID, Options>): RuleListener {
   // Get the rule policy from options, default to 1 (enforce shorthand)
   const policy = context.options[0] ?? defaultOptions[0];
-  // Get JSX configuration from context and comments
   const jsxConfig = {
     ...getJsxConfigFromContext(context),
     ...getJsxConfigFromAnnotation(context),

packages/plugins/eslint-plugin-react-x/src/rules/jsx-uses-react.ts

@@ -30,7 +30,6 @@ export default createRule<[], MessageID>({
 });
 
 export function create(context: RuleContext<MessageID, []>): RuleListener {
-  // Get JSX configuration from context and annotations
   const jsxConfig = {
     ...getJsxConfigFromContext(context),
     ...getJsxConfigFromAnnotation(context),

packages/plugins/eslint-plugin-react-x/src/rules/no-access-state-in-setstate.ts

@@ -54,50 +54,42 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
     return {};
   }
   // Stack to track class declarations and whether they are React components
-  const classEntries: [
-    node: TSESTree.ClassDeclaration | TSESTree.ClassExpression,
-    isComponent: boolean,
-  ][] = [];
+  const classStack: [node: TSESTree.ClassDeclaration | TSESTree.ClassExpression, isComponent: boolean][] = [];
   // Stack to track method definitions and whether they are static
-  const methodEntries: [
-    node: AST.TSESTreeMethodOrProperty,
-    isStatic: boolean,
-  ][] = [];
+  const methodStack: [node: AST.TSESTreeMethodOrProperty, isStatic: boolean][] = [];
   // Stack to track `setState` call expressions
-  const setStateEntries: [
-    node: TSESTree.CallExpression,
-    hasThisState: boolean,
-  ][] = [];
+  const setStateStack: [node: TSESTree.CallExpression, hasThisState: boolean][] = [];
+
   return {
     // Push `setState` calls to the stack upon entry
     CallExpression(node) {
       if (!isThisSetState(node)) {
         return;
       }
-      setStateEntries.push([node, false]);
+      setStateStack.push([node, false]);
     },
     // Pop `setState` calls from the stack upon exit
     "CallExpression:exit"(node) {
       if (!isThisSetState(node)) {
         return;
       }
-      setStateEntries.pop();
+      setStateStack.pop();
     },
     // Push class declarations to the stack upon entry
     ClassDeclaration(node) {
-      classEntries.push([node, isClassComponent(node)]);
+      classStack.push([node, isClassComponent(node)]);
     },
     // Pop class declarations from the stack upon exit
     "ClassDeclaration:exit"() {
-      classEntries.pop();
+      classStack.pop();
     },
     // Push class expressions to the stack upon entry
     ClassExpression(node) {
-      classEntries.push([node, isClassComponent(node)]);
+      classStack.push([node, isClassComponent(node)]);
     },
     // Pop class expressions from the stack upon exit
     "ClassExpression:exit"() {
-      classEntries.pop();
+      classStack.pop();
     },
     // Main logic for detecting `this.state` access
     MemberExpression(node) {
@@ -106,17 +98,17 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
         return;
       }
       // Ensure we are inside a React class component
-      const [currClass, isComponent = false] = classEntries.at(-1) ?? [];
+      const [currClass, isComponent = false] = classStack.at(-1) ?? [];
       if (currClass == null || !isComponent) {
         return;
       }
       // Ensure we are inside a non-static method
-      const [currMethod, isStatic = false] = methodEntries.at(-1) ?? [];
+      const [currMethod, isStatic = false] = methodStack.at(-1) ?? [];
       if (currMethod == null || isStatic) {
         return;
       }
       // Ensure we are inside a `setState` call
-      const [setState, hasThisState = false] = setStateEntries.at(-1) ?? [];
+      const [setState, hasThisState = false] = setStateStack.at(-1) ?? [];
       if (setState == null || hasThisState) {
         return;
       }
@@ -129,33 +121,33 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
     },
     // Push method definitions to the stack upon entry
     MethodDefinition(node) {
-      methodEntries.push([node, node.static]);
+      methodStack.push([node, node.static]);
     },
     // Pop method definitions from the stack upon exit
     "MethodDefinition:exit"() {
-      methodEntries.pop();
+      methodStack.pop();
     },
     // Push property definitions to the stack upon entry
     PropertyDefinition(node) {
-      methodEntries.push([node, node.static]);
+      methodStack.push([node, node.static]);
     },
     // Pop property definitions from the stack upon exit
     "PropertyDefinition:exit"() {
-      methodEntries.pop();
+      methodStack.pop();
     },
     // Logic for detecting destructuring of `this.state`
     VariableDeclarator(node) {
       // Get current class and method context
-      const [currClass, isComponent = false] = classEntries.at(-1) ?? [];
+      const [currClass, isComponent = false] = classStack.at(-1) ?? [];
       if (currClass == null || !isComponent) {
         return;
       }
-      const [currMethod, isStatic = false] = methodEntries.at(-1) ?? [];
+      const [currMethod, isStatic = false] = methodStack.at(-1) ?? [];
       if (currMethod == null || isStatic) {
         return;
       }
       // Ensure we are inside a `setState` call
-      const [setState, hasThisState = false] = setStateEntries.at(-1) ?? [];
+      const [setState, hasThisState = false] = setStateStack.at(-1) ?? [];
       if (setState == null || hasThisState) {
         return;
       }

packages/plugins/eslint-plugin-react-x/src/rules/no-context-provider.ts

@@ -44,11 +44,8 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       // Get the full name of the JSX element: "Foo.MyContext.Provider"
       const fullName = getJsxElementType(context, node);
       const parts = fullName.split(".");
-      // Get the last part of the name: "Provider"
       const selfName = parts.pop();
-      // Reconstruct the context name: "Foo.MyContext"
       const contextFullName = parts.join(".");
-      // Get the context name itself: "MyContext"
       const contextSelfName = parts.pop();
       // Exit if the element is not a "Provider"
       if (selfName !== "Provider") return;
@@ -57,7 +54,6 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       context.report({
         messageId: "noContextProvider",
         node,
-        // Provide an auto-fix
         fix(fixer) {
           // Ensure the context name is a valid component name before applying the fix
           if (!isComponentNameLoose(contextSelfName)) return null;

packages/plugins/eslint-plugin-react-x/src/rules/no-missing-component-display-name.ts

@@ -33,7 +33,6 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
   // Fast path: skip if `memo` or `forwardRef` is not present in the file
   if (!context.sourceCode.text.includes("memo") && !context.sourceCode.text.includes("forwardRef")) return {};
 
-  // Initialize the component collector
   const {
     ctx,
     listeners,
@@ -48,10 +47,8 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
 
   return {
     ...listeners,
-    // After the program is parsed, check all collected components
     "Program:exit"(program) {
       const components = ctx.getAllComponents(program);
-      // Iterate over all found components
       for (const { node, displayName, flag } of components.values()) {
         // Check if the component is wrapped with `forwardRef` or `memo`
         const isMemoOrForwardRef = (flag & (ComponentFlag.ForwardRef | ComponentFlag.Memo)) > 0n;

packages/plugins/eslint-plugin-react-x/src/rules/no-missing-context-display-name.ts

@@ -52,7 +52,6 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       if (!isCreateContextCall(context, node)) return;
       createCalls.push(node);
     },
-    // After traversing the whole program, check for missing displayNames
     "Program:exit"() {
       for (const call of createCalls) {
         // Get the variable identifier for the context

packages/plugins/eslint-plugin-react-x/src/rules/no-prop-types.ts

@@ -34,9 +34,7 @@ export default createRule<[], MessageID>({
 
 export function create(context: RuleContext<MessageID, []>): RuleListener {
   // Fast path: skip if `propTypes` is not present in the file for performance
-  if (!context.sourceCode.text.includes("propTypes")) {
-    return {};
-  }
+  if (!context.sourceCode.text.includes("propTypes")) return {};
   return {
     // Handles cases like: `MyComponent.propTypes = ...`
     AssignmentExpression(node) {

packages/plugins/eslint-plugin-react-x/src/rules/no-unused-class-component-members.ts

@@ -74,17 +74,17 @@ export default createRule<[], MessageID>({
 
 export function create(context: RuleContext<MessageID, []>): RuleListener {
   // A stack to keep track of class nodes, to handle nested classes
-  const classEntries: AST.TSESTreeClass[] = [];
+  const classStack: AST.TSESTreeClass[] = [];
   // A stack to keep track of method/property nodes
-  const methodEntries: AST.TSESTreeMethodOrProperty[] = [];
+  const methodStack: AST.TSESTreeMethodOrProperty[] = [];
   // Stores all defined properties and methods for each class component
   const propertyDefs = new WeakMap<AST.TSESTreeClass, Set<Property>>();
   // Stores all used properties and methods for each class component
   const propertyUsages = new WeakMap<AST.TSESTreeClass, Set<string>>();
 
   // Called when the AST traversal enters a class declaration or expression
   function classEnter(node: AST.TSESTreeClass) {
-    classEntries.push(node);
+    classStack.push(node);
     if (!isClassComponent(node)) {
       return;
     }
@@ -95,7 +95,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
 
   // Called when the AST traversal exits a class declaration or expression
   function classExit() {
-    const currentClass = classEntries.pop();
+    const currentClass = classStack.pop();
     if (currentClass == null || !isClassComponent(currentClass)) {
       return;
     }
@@ -129,8 +129,8 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
 
   // Called when the AST traversal enters a method or property definition
   function methodEnter(node: AST.TSESTreeMethodOrProperty) {
-    methodEntries.push(node);
-    const currentClass = classEntries.at(-1);
+    methodStack.push(node);
+    const currentClass = classStack.at(-1);
     if (currentClass == null || !isClassComponent(currentClass)) {
       return;
     }
@@ -146,7 +146,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
 
   // Called when the AST traversal exits a method or property definition
   function methodExit() {
-    methodEntries.pop();
+    methodStack.pop();
   }
 
   return {
@@ -156,8 +156,8 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
     "ClassExpression:exit": classExit,
     // Visitor for MemberExpression to track property usages and definitions
     MemberExpression(node) {
-      const currentClass = classEntries.at(-1);
-      const currentMethod = methodEntries.at(-1);
+      const currentClass = classStack.at(-1);
+      const currentMethod = methodStack.at(-1);
       if (currentClass == null || currentMethod == null) {
         return;
       }
@@ -185,8 +185,8 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
     "PropertyDefinition:exit": methodExit,
     // Visitor for VariableDeclarator to track property usages via destructuring
     VariableDeclarator(node) {
-      const currentClass = classEntries.at(-1);
-      const currentMethod = methodEntries.at(-1);
+      const currentClass = classStack.at(-1);
+      const currentMethod = methodStack.at(-1);
       if (currentClass == null || currentMethod == null) {
         return;
       }