From 4e1c700378dfdea372c277f3cd4ddef4524cbbe2 Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Thu, 7 Aug 2025 22:59:59 +0900
Subject: [PATCH 01/12] implement

---
 docs/rules/no-ineffective-attrs.md            |  13 ++
 packages/eslint-plugin/lib/rules/index.js     |   2 +
 .../lib/rules/no-ineffective-attrs.js         | 126 ++++++++++++++++++
 .../tests/rules/no-ineffective-attrs.test.js  |  15 +++
 4 files changed, 156 insertions(+)
 create mode 100644 docs/rules/no-ineffective-attrs.md
 create mode 100644 packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
 create mode 100644 packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js

diff --git a/docs/rules/no-ineffective-attrs.md b/docs/rules/no-ineffective-attrs.md
new file mode 100644
index 00000000..2a8c2bb6
--- /dev/null
+++ b/docs/rules/no-ineffective-attrs.md
@@ -0,0 +1,13 @@
+# no-ineffective-attrs
+
+## How to use
+
+```js,.eslintrc.js
+module.exports = {
+  rules: {
+    "@html-eslint/no-ineffective-attrs": "error",
+  },
+};
+```
+
+## Rule Details
diff --git a/packages/eslint-plugin/lib/rules/index.js b/packages/eslint-plugin/lib/rules/index.js
index 1a3113c0..7712a3c3 100644
--- a/packages/eslint-plugin/lib/rules/index.js
+++ b/packages/eslint-plugin/lib/rules/index.js
@@ -51,6 +51,7 @@ const noDuplicateClass = require("./no-duplicate-class");
 const noEmptyHeadings = require("./no-empty-headings");
 const noInvalidEntity = require("./no-invalid-entity");
 const noDuplicateInHead = require("./no-duplicate-in-head");
+const noIneffectiveAttrs = require("./no-ineffective-attrs");
 // import new rule here ↑
 // DO NOT REMOVE THIS COMMENT
 
@@ -108,6 +109,7 @@ const rules = {
   "no-empty-headings": noEmptyHeadings,
   "no-invalid-entity": noInvalidEntity,
   "no-duplicate-in-head": noDuplicateInHead,
+  "no-ineffective-attrs": noIneffectiveAttrs,
   // export new rule here ↑
   // DO NOT REMOVE THIS COMMENT
 };
diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
new file mode 100644
index 00000000..a6f81fc3
--- /dev/null
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -0,0 +1,126 @@
+/**
+ * @import {Tag} from "@html-eslint/types"
+ * @import {RuleModule} from "../types";
+ * @typedef {{ tag: string; }} Checker
+ */
+
+const MESSAGE_IDS = {
+  UNEXPECTED: "unexpected",
+};
+
+function getAttrValue(node, attrName) {
+  const attr = node.attributes.find(
+    (a) => a.type === "Attribute" && a.key.name === attrName
+  );
+  if (!attr || !attr.value || attr.value.type !== "Text") return undefined;
+  return attr.value.value;
+}
+
+function hasAttr(node, attrName) {
+  return node.attributes.some(
+    (a) => a.type === "Attribute" && a.key.name === attrName
+  );
+}
+
+const checkers = [
+  {
+    tag: "input",
+    attr: "multiple",
+    when: (node) => {
+      const type = getAttrValue(node, "type") || "text";
+      return [
+        "text",
+        "password",
+        "radio",
+        "checkbox",
+        "image",
+        "hidden",
+        "reset",
+        "button",
+      ].includes(type);
+    },
+    message: 'The "multiple" attribute has no effect on this input type.',
+  },
+  {
+    tag: "input",
+    attr: "accept",
+    when: (node) => {
+      const type = getAttrValue(node, "type") || "text";
+      return type !== "file";
+    },
+    message:
+      'The "accept" attribute has no effect unless input type is "file".',
+  },
+  {
+    tag: "script",
+    attr: "defer",
+    when: (node) => !hasAttr(node, "src"),
+    message: 'The "defer" attribute has no effect on inline scripts.',
+  },
+  {
+    tag: "textarea",
+    attr: "value",
+    when: () => true,
+    message:
+      'The "value" attribute has no effect on <textarea>. Use its content instead.',
+  },
+  {
+    tag: "a",
+    attr: "download",
+    when: (node) => !hasAttr(node, "href"),
+    message: 'The "download" attribute has no effect without an "href".',
+  },
+  {
+    tag: "form",
+    attr: "enctype",
+    when: (node) => {
+      const method = (getAttrValue(node, "method") || "get").toLowerCase();
+      return method !== "post";
+    },
+    message: 'The "enctype" attribute is only relevant when method is "post".',
+  },
+];
+
+/**
+ * @type {RuleModule<[]>}
+ */
+module.exports = {
+  name: "no-ineffective-attrs",
+  meta: {
+    docs: {
+      description: "Disallow HTML attributes that have no effect in context",
+      category: "Possible Errors",
+      recommended: false,
+    },
+    messages: {
+      ineffective: "{{ message }}",
+    },
+    schema: [],
+    type: "problem",
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Tag(node) {
+        for (const check of checks) {
+          if (node.tagName !== check.tag) continue;
+
+          for (const attr of node.attributes) {
+            if (attr.type !== "Attribute") continue;
+            if (attr.key.name !== check.attr) continue;
+
+            if (check.when(node, attr)) {
+              context.report({
+                loc: attr.loc,
+                messageId: "ineffective",
+                data: {
+                  message: check.message,
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
new file mode 100644
index 00000000..c0167c64
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -0,0 +1,15 @@
+const createRuleTester = require("../rule-tester");
+const rule = require("../../lib/rules/no-ineffective-attrs");
+
+const ruleTester = createRuleTester();
+const templateRuleTester = createRuleTester("espree");
+
+ruleTester.run("no-ineffective-attrs", rule, {
+  valid: [],
+  invalid: [],
+});
+
+templateRuleTester.run("[template] no-ineffective-attrs", rule, {
+  valid: [],
+  invalid: [],
+});

From 7650814b03b02191322c9c38c9f4be89acf49a15 Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Thu, 7 Aug 2025 23:49:07 +0900
Subject: [PATCH 02/12] feat: add no-ineffective-attrs

---
 docs/rules/no-ineffective-attrs.md            |  52 ++++++++
 .../lib/rules/no-ineffective-attrs.js         |  67 ++++++++--
 .../tests/rules/no-ineffective-attrs.test.js  | 121 +++++++++++++++++-
 3 files changed, 224 insertions(+), 16 deletions(-)

diff --git a/docs/rules/no-ineffective-attrs.md b/docs/rules/no-ineffective-attrs.md
index 2a8c2bb6..2e47ab87 100644
--- a/docs/rules/no-ineffective-attrs.md
+++ b/docs/rules/no-ineffective-attrs.md
@@ -11,3 +11,55 @@ module.exports = {
 ```
 
 ## Rule Details
+
+This rule disallows HTML attributes that have no effect in their context. Such attributes may indicate errors or unnecessary code that should be removed.
+
+Examples of **incorrect** code for this rule:
+
+```html
+<!-- multiple has no effect on text inputs -->
+<input type="text" multiple />
+
+<!-- accept only works with file inputs -->
+<input type="text" accept=".jpg,.png" />
+
+<!-- defer has no effect on inline scripts -->
+<script defer>
+  console.log("hello");
+</script>
+
+<!-- value attribute has no effect on textarea -->
+<textarea value="default">actual content</textarea>
+
+<!-- download needs href to work -->
+<a download="file.pdf">Download</a>
+
+<!-- enctype only applies to POST forms -->
+<form method="get" enctype="multipart/form-data">
+  <input type="text" name="query" />
+</form>
+```
+
+Examples of **correct** code for this rule:
+
+```html
+<!-- multiple works with file inputs -->
+<input type="file" multiple />
+
+<!-- accept works with file inputs -->
+<input type="file" accept=".jpg,.png" />
+
+<!-- defer works with external scripts -->
+<script defer src="script.js"></script>
+
+<!-- textarea uses content, not value attribute -->
+<textarea>default content</textarea>
+
+<!-- download works when href is present -->
+<a href="file.pdf" download="file.pdf">Download</a>
+
+<!-- enctype applies to POST forms -->
+<form method="post" enctype="multipart/form-data">
+  <input type="file" name="upload" />
+</form>
+```
diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index a6f81fc3..60447179 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -1,27 +1,36 @@
 /**
- * @import {Tag} from "@html-eslint/types"
  * @import {RuleModule} from "../types";
- * @typedef {{ tag: string; }} Checker
+ * @import {Tag} from "@html-eslint/types"
+ * @typedef {{ tag: string; attr: string; when: (node: Tag) => boolean; message: string; }} Checker
  */
 
-const MESSAGE_IDS = {
-  UNEXPECTED: "unexpected",
-};
-
+/**
+ * @param {Tag} node
+ * @param {string} attrName
+ * @returns {string | undefined}
+ */
 function getAttrValue(node, attrName) {
   const attr = node.attributes.find(
-    (a) => a.type === "Attribute" && a.key.name === attrName
+    (a) => a.type === "Attribute" && a.key.value === attrName
   );
-  if (!attr || !attr.value || attr.value.type !== "Text") return undefined;
+  if (!attr || !attr.value) return undefined;
   return attr.value.value;
 }
 
+/**
+ * @param {Tag} node
+ * @param {string} attrName
+ * @returns {boolean}
+ */
 function hasAttr(node, attrName) {
   return node.attributes.some(
-    (a) => a.type === "Attribute" && a.key.name === attrName
+    (a) => a.type === "Attribute" && a.key.value === attrName
   );
 }
 
+/**
+ * @type {Checker[]}
+ */
 const checkers = [
   {
     tag: "input",
@@ -88,7 +97,8 @@ module.exports = {
   name: "no-ineffective-attrs",
   meta: {
     docs: {
-      description: "Disallow HTML attributes that have no effect in context",
+      description:
+        "Disallow HTML attributes that have no effect in their context",
       category: "Possible Errors",
       recommended: false,
     },
@@ -99,17 +109,46 @@ module.exports = {
     type: "problem",
   },
   defaultOptions: [],
+  /**
+   * @param {any} context
+   */
   create(context) {
     return {
+      /**
+       * @param {Tag} node
+       */
       Tag(node) {
-        for (const check of checks) {
-          if (node.tagName !== check.tag) continue;
+        for (const check of checkers) {
+          if (node.name !== check.tag) continue;
+
+          for (const attr of node.attributes) {
+            if (attr.type !== "Attribute") continue;
+            if (attr.key.value !== check.attr) continue;
+
+            if (check.when(node)) {
+              context.report({
+                loc: attr.loc,
+                messageId: "ineffective",
+                data: {
+                  message: check.message,
+                },
+              });
+            }
+          }
+        }
+      },
+      /**
+       * @param {any} node
+       */
+      ScriptTag(node) {
+        for (const check of checkers) {
+          if (check.tag !== "script") continue;
 
           for (const attr of node.attributes) {
             if (attr.type !== "Attribute") continue;
-            if (attr.key.name !== check.attr) continue;
+            if (attr.key.value !== check.attr) continue;
 
-            if (check.when(node, attr)) {
+            if (check.when(node)) {
               context.report({
                 loc: attr.loc,
                 messageId: "ineffective",
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index c0167c64..7c00d11b 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -5,8 +5,125 @@ const ruleTester = createRuleTester();
 const templateRuleTester = createRuleTester("espree");
 
 ruleTester.run("no-ineffective-attrs", rule, {
-  valid: [],
-  invalid: [],
+  valid: [
+    // Valid input types for multiple attribute
+    {
+      code: '<input type="email" multiple>',
+    },
+    {
+      code: '<input type="file" multiple>',
+    },
+    {
+      code: '<select multiple></select>',
+    },
+    
+    // Valid file input with accept
+    {
+      code: '<input type="file" accept=".jpg,.png">',
+    },
+    
+    // Valid script with src and defer
+    {
+      code: '<script src="script.js" defer></script>',
+    },
+    
+    // Valid textarea without value attribute
+    {
+      code: '<textarea>content</textarea>',
+    },
+    
+    // Valid anchor with href and download
+    {
+      code: '<a href="file.pdf" download>Download</a>',
+    },
+    
+    // Valid form with POST method and enctype
+    {
+      code: '<form method="post" enctype="multipart/form-data"></form>',
+    },
+  ],
+  invalid: [
+    // Invalid multiple on text input
+    {
+      code: '<input type="text" multiple>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: { message: 'The "multiple" attribute has no effect on this input type.' },
+        },
+      ],
+    },
+    // Invalid multiple on checkbox
+    {
+      code: '<input type="checkbox" multiple>',
+      errors: [
+        {
+          messageId: "ineffective", 
+          data: { message: 'The "multiple" attribute has no effect on this input type.' },
+        },
+      ],
+    },
+    // Invalid accept on non-file input
+    {
+      code: '<input type="text" accept=".jpg">',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: { message: 'The "accept" attribute has no effect unless input type is "file".' },
+        },
+      ],
+    },
+    // Invalid defer on inline script
+    {
+      code: '<script defer></script>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: { message: 'The "defer" attribute has no effect on inline scripts.' },
+        },
+      ],
+    },
+    // Invalid value on textarea
+    {
+      code: '<textarea value="text">content</textarea>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: { message: 'The "value" attribute has no effect on <textarea>. Use its content instead.' },
+        },
+      ],
+    },
+    // Invalid download without href
+    {
+      code: '<a download>Download</a>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: { message: 'The "download" attribute has no effect without an "href".' },
+        },
+      ],
+    },
+    // Invalid enctype on GET form
+    {
+      code: '<form method="get" enctype="multipart/form-data"></form>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: { message: 'The "enctype" attribute is only relevant when method is "post".' },
+        },
+      ],
+    },
+    // Invalid enctype on default method form
+    {
+      code: '<form enctype="multipart/form-data"></form>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: { message: 'The "enctype" attribute is only relevant when method is "post".' },
+        },
+      ],
+    },
+  ],
 });
 
 templateRuleTester.run("[template] no-ineffective-attrs", rule, {

From 9caa3a438320a0cac6a0a580c1d5bc85bf113167 Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Thu, 7 Aug 2025 23:49:44 +0900
Subject: [PATCH 03/12] fix format

---
 .../tests/rules/no-ineffective-attrs.test.js  | 59 +++++++++++++------
 1 file changed, 41 insertions(+), 18 deletions(-)

diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index 7c00d11b..1f50323f 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -14,29 +14,29 @@ ruleTester.run("no-ineffective-attrs", rule, {
       code: '<input type="file" multiple>',
     },
     {
-      code: '<select multiple></select>',
+      code: "<select multiple></select>",
     },
-    
+
     // Valid file input with accept
     {
       code: '<input type="file" accept=".jpg,.png">',
     },
-    
+
     // Valid script with src and defer
     {
       code: '<script src="script.js" defer></script>',
     },
-    
+
     // Valid textarea without value attribute
     {
-      code: '<textarea>content</textarea>',
+      code: "<textarea>content</textarea>",
     },
-    
+
     // Valid anchor with href and download
     {
       code: '<a href="file.pdf" download>Download</a>',
     },
-    
+
     // Valid form with POST method and enctype
     {
       code: '<form method="post" enctype="multipart/form-data"></form>',
@@ -49,7 +49,10 @@ ruleTester.run("no-ineffective-attrs", rule, {
       errors: [
         {
           messageId: "ineffective",
-          data: { message: 'The "multiple" attribute has no effect on this input type.' },
+          data: {
+            message:
+              'The "multiple" attribute has no effect on this input type.',
+          },
         },
       ],
     },
@@ -58,8 +61,11 @@ ruleTester.run("no-ineffective-attrs", rule, {
       code: '<input type="checkbox" multiple>',
       errors: [
         {
-          messageId: "ineffective", 
-          data: { message: 'The "multiple" attribute has no effect on this input type.' },
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "multiple" attribute has no effect on this input type.',
+          },
         },
       ],
     },
@@ -69,17 +75,22 @@ ruleTester.run("no-ineffective-attrs", rule, {
       errors: [
         {
           messageId: "ineffective",
-          data: { message: 'The "accept" attribute has no effect unless input type is "file".' },
+          data: {
+            message:
+              'The "accept" attribute has no effect unless input type is "file".',
+          },
         },
       ],
     },
     // Invalid defer on inline script
     {
-      code: '<script defer></script>',
+      code: "<script defer></script>",
       errors: [
         {
           messageId: "ineffective",
-          data: { message: 'The "defer" attribute has no effect on inline scripts.' },
+          data: {
+            message: 'The "defer" attribute has no effect on inline scripts.',
+          },
         },
       ],
     },
@@ -89,17 +100,23 @@ ruleTester.run("no-ineffective-attrs", rule, {
       errors: [
         {
           messageId: "ineffective",
-          data: { message: 'The "value" attribute has no effect on <textarea>. Use its content instead.' },
+          data: {
+            message:
+              'The "value" attribute has no effect on <textarea>. Use its content instead.',
+          },
         },
       ],
     },
     // Invalid download without href
     {
-      code: '<a download>Download</a>',
+      code: "<a download>Download</a>",
       errors: [
         {
           messageId: "ineffective",
-          data: { message: 'The "download" attribute has no effect without an "href".' },
+          data: {
+            message:
+              'The "download" attribute has no effect without an "href".',
+          },
         },
       ],
     },
@@ -109,7 +126,10 @@ ruleTester.run("no-ineffective-attrs", rule, {
       errors: [
         {
           messageId: "ineffective",
-          data: { message: 'The "enctype" attribute is only relevant when method is "post".' },
+          data: {
+            message:
+              'The "enctype" attribute is only relevant when method is "post".',
+          },
         },
       ],
     },
@@ -119,7 +139,10 @@ ruleTester.run("no-ineffective-attrs", rule, {
       errors: [
         {
           messageId: "ineffective",
-          data: { message: 'The "enctype" attribute is only relevant when method is "post".' },
+          data: {
+            message:
+              'The "enctype" attribute is only relevant when method is "post".',
+          },
         },
       ],
     },

From 7a329284f3b46ac2d4b0de619c36c13aea2ee50a Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Thu, 7 Aug 2025 23:54:04 +0900
Subject: [PATCH 04/12] Update no-ineffective-attrs.js

---
 packages/eslint-plugin/lib/rules/no-ineffective-attrs.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index 60447179..7806f2d7 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -4,6 +4,8 @@
  * @typedef {{ tag: string; attr: string; when: (node: Tag) => boolean; message: string; }} Checker
  */
 
+const { RULE_CATEGORY } = require("../constants");
+
 /**
  * @param {Tag} node
  * @param {string} attrName
@@ -99,7 +101,7 @@ module.exports = {
     docs: {
       description:
         "Disallow HTML attributes that have no effect in their context",
-      category: "Possible Errors",
+      category: RULE_CATEGORY.BEST_PRACTICE,
       recommended: false,
     },
     messages: {

From c248ed2ae517b6585fcc28e56ed0cd8239791c2b Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 00:07:42 +0900
Subject: [PATCH 05/12] add cases

---
 .../lib/rules/no-ineffective-attrs.js          | 18 +++++++-----------
 packages/eslint-plugin/lib/rules/utils/node.js | 12 ++++++++++++
 .../tests/rules/no-ineffective-attrs.test.js   | 17 +++++++++++++++++
 3 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index 7806f2d7..92ea1e32 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -5,6 +5,7 @@
  */
 
 const { RULE_CATEGORY } = require("../constants");
+const { hasAttr } = require("./utils/node");
 
 /**
  * @param {Tag} node
@@ -19,17 +20,6 @@ function getAttrValue(node, attrName) {
   return attr.value.value;
 }
 
-/**
- * @param {Tag} node
- * @param {string} attrName
- * @returns {boolean}
- */
-function hasAttr(node, attrName) {
-  return node.attributes.some(
-    (a) => a.type === "Attribute" && a.key.value === attrName
-  );
-}
-
 /**
  * @type {Checker[]}
  */
@@ -68,6 +58,12 @@ const checkers = [
     when: (node) => !hasAttr(node, "src"),
     message: 'The "defer" attribute has no effect on inline scripts.',
   },
+  {
+    tag: "script",
+    attr: "async",
+    when: (node) => !hasAttr(node, "src"),
+    message: 'The "async" attribute has no effect on inline scripts.',
+  },
   {
     tag: "textarea",
     attr: "value",
diff --git a/packages/eslint-plugin/lib/rules/utils/node.js b/packages/eslint-plugin/lib/rules/utils/node.js
index 1caa206a..962ebc31 100644
--- a/packages/eslint-plugin/lib/rules/utils/node.js
+++ b/packages/eslint-plugin/lib/rules/utils/node.js
@@ -17,6 +17,17 @@ function findAttr(node, key) {
   );
 }
 
+/**
+ * @param {Tag} node
+ * @param {string} attrName
+ * @returns {boolean}
+ */
+function hasAttr(node, attrName) {
+  return node.attributes.some(
+    (a) => a.type === "Attribute" && a.key.value === attrName
+  );
+}
+
 /**
  * Checks whether a node's attributes is empty or not.
  * @param {Tag | ScriptTag | StyleTag} node
@@ -254,4 +265,5 @@ module.exports = {
   isRangesOverlap,
   getTemplateTokens,
   hasTemplate,
+  hasAttr,
 };
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index 1f50323f..b1a814a4 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -26,6 +26,11 @@ ruleTester.run("no-ineffective-attrs", rule, {
     {
       code: '<script src="script.js" defer></script>',
     },
+    
+    // Valid script with src and async
+    {
+      code: '<script src="script.js" async></script>',
+    },
 
     // Valid textarea without value attribute
     {
@@ -94,6 +99,18 @@ ruleTester.run("no-ineffective-attrs", rule, {
         },
       ],
     },
+    // Invalid async on inline script
+    {
+      code: "<script async></script>",
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message: 'The "async" attribute has no effect on inline scripts.',
+          },
+        },
+      ],
+    },
     // Invalid value on textarea
     {
       code: '<textarea value="text">content</textarea>',

From 3775d704d58e967d05079771d310586eabbe4772 Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 00:55:03 +0900
Subject: [PATCH 06/12] refactor

---
 .../lib/rules/no-ineffective-attrs.js         | 132 +++++++++---------
 .../tests/rules/no-ineffective-attrs.test.js  |  20 +--
 2 files changed, 66 insertions(+), 86 deletions(-)

diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index 92ea1e32..f284b41a 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -1,7 +1,7 @@
 /**
  * @import {RuleModule} from "../types";
  * @import {Tag} from "@html-eslint/types"
- * @typedef {{ tag: string; attr: string; when: (node: Tag) => boolean; message: string; }} Checker
+ * @typedef {{ attr: string; when: (node: Tag) => boolean; message: string; }} AttributeChecker
  */
 
 const { RULE_CATEGORY } = require("../constants");
@@ -21,72 +21,68 @@ function getAttrValue(node, attrName) {
 }
 
 /**
- * @type {Checker[]}
+ * @type {Record<string, AttributeChecker[]>}
  */
-const checkers = [
-  {
-    tag: "input",
-    attr: "multiple",
-    when: (node) => {
-      const type = getAttrValue(node, "type") || "text";
-      return [
-        "text",
-        "password",
-        "radio",
-        "checkbox",
-        "image",
-        "hidden",
-        "reset",
-        "button",
-      ].includes(type);
+const checkersByTag = {
+  input: [
+    {
+      attr: "multiple",
+      when: (node) => {
+        const type = getAttrValue(node, "type") || "text";
+        return [
+          "text",
+          "password",
+          "radio",
+          "checkbox",
+          "image",
+          "hidden",
+          "reset",
+          "button",
+        ].includes(type);
+      },
+      message: 'The "multiple" attribute has no effect on this input type.',
     },
-    message: 'The "multiple" attribute has no effect on this input type.',
-  },
-  {
-    tag: "input",
-    attr: "accept",
-    when: (node) => {
-      const type = getAttrValue(node, "type") || "text";
-      return type !== "file";
+    {
+      attr: "accept",
+      when: (node) => {
+        const type = getAttrValue(node, "type") || "text";
+        return type !== "file";
+      },
+      message:
+        'The "accept" attribute has no effect unless input type is "file".',
     },
-    message:
-      'The "accept" attribute has no effect unless input type is "file".',
-  },
-  {
-    tag: "script",
-    attr: "defer",
-    when: (node) => !hasAttr(node, "src"),
-    message: 'The "defer" attribute has no effect on inline scripts.',
-  },
-  {
-    tag: "script",
-    attr: "async",
-    when: (node) => !hasAttr(node, "src"),
-    message: 'The "async" attribute has no effect on inline scripts.',
-  },
-  {
-    tag: "textarea",
-    attr: "value",
-    when: () => true,
-    message:
-      'The "value" attribute has no effect on <textarea>. Use its content instead.',
-  },
-  {
-    tag: "a",
-    attr: "download",
-    when: (node) => !hasAttr(node, "href"),
-    message: 'The "download" attribute has no effect without an "href".',
-  },
-  {
-    tag: "form",
-    attr: "enctype",
-    when: (node) => {
-      const method = (getAttrValue(node, "method") || "get").toLowerCase();
-      return method !== "post";
+  ],
+  script: [
+    {
+      attr: "defer",
+      when: (node) => !hasAttr(node, "src"),
+      message: 'The "defer" attribute has no effect on inline scripts.',
     },
-    message: 'The "enctype" attribute is only relevant when method is "post".',
-  },
-];
+    {
+      attr: "async",
+      when: (node) => !hasAttr(node, "src"),
+      message: 'The "async" attribute has no effect on inline scripts.',
+    },
+  ],
+  a: [
+    {
+      attr: "download",
+      when: (node) => !hasAttr(node, "href"),
+      message: 'The "download" attribute has no effect without an "href".',
+    },
+  ],
+  form: [
+    {
+      attr: "enctype",
+      when: (node) => {
+        const method = (getAttrValue(node, "method") || "get").toLowerCase();
+        return method !== "post";
+      },
+      message:
+        'The "enctype" attribute is only relevant when method is "post".',
+    },
+  ],
+};
 
 /**
  * @type {RuleModule<[]>}
@@ -116,9 +112,10 @@ module.exports = {
        * @param {Tag} node
        */
       Tag(node) {
-        for (const check of checkers) {
-          if (node.name !== check.tag) continue;
+        const tagCheckers = checkersByTag[node.name];
+        if (!tagCheckers) return;
 
+        for (const check of tagCheckers) {
           for (const attr of node.attributes) {
             if (attr.type !== "Attribute") continue;
             if (attr.key.value !== check.attr) continue;
@@ -139,9 +136,10 @@ module.exports = {
        * @param {any} node
        */
       ScriptTag(node) {
-        for (const check of checkers) {
-          if (check.tag !== "script") continue;
+        const scriptCheckers = checkersByTag.script;
+        if (!scriptCheckers) return;
 
+        for (const check of scriptCheckers) {
           for (const attr of node.attributes) {
             if (attr.type !== "Attribute") continue;
             if (attr.key.value !== check.attr) continue;
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index b1a814a4..03a1ae0e 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -26,17 +26,12 @@ ruleTester.run("no-ineffective-attrs", rule, {
     {
       code: '<script src="script.js" defer></script>',
     },
-    
+
     // Valid script with src and async
     {
       code: '<script src="script.js" async></script>',
     },
 
-    // Valid textarea without value attribute
-    {
-      code: "<textarea>content</textarea>",
-    },
-
     // Valid anchor with href and download
     {
       code: '<a href="file.pdf" download>Download</a>',
@@ -111,19 +106,6 @@ ruleTester.run("no-ineffective-attrs", rule, {
         },
       ],
     },
-    // Invalid value on textarea
-    {
-      code: '<textarea value="text">content</textarea>',
-      errors: [
-        {
-          messageId: "ineffective",
-          data: {
-            message:
-              'The "value" attribute has no effect on <textarea>. Use its content instead.',
-          },
-        },
-      ],
-    },
     // Invalid download without href
     {
       code: "<a download>Download</a>",

From 1a6c81a363e2557562caf18c89c63909038ec9ac Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 01:59:58 +0900
Subject: [PATCH 07/12] handle template literals

---
 .../lib/rules/no-ineffective-attrs.js         | 24 ++++---------
 .../eslint-plugin/lib/rules/utils/node.js     |  2 +-
 .../tests/rules/no-ineffective-attrs.test.js  | 34 ++++++-------------
 3 files changed, 18 insertions(+), 42 deletions(-)

diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index f284b41a..fa1870c9 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -1,14 +1,15 @@
 /**
  * @import {RuleModule} from "../types";
- * @import {Tag} from "@html-eslint/types"
- * @typedef {{ attr: string; when: (node: Tag) => boolean; message: string; }} AttributeChecker
+ * @import {Tag, ScriptTag} from "@html-eslint/types"
+ * @typedef {{ attr: string; when: (node: Tag | ScriptTag) => boolean; message: string; }} AttributeChecker
  */
 
 const { RULE_CATEGORY } = require("../constants");
 const { hasAttr } = require("./utils/node");
+const { createVisitors } = require("./utils/visitors");
 
 /**
- * @param {Tag} node
+ * @param {Tag | ScriptTag} node
  * @param {string} attrName
  * @returns {string | undefined}
  */
@@ -71,17 +72,6 @@ const checkersByTag = {
       message: 'The "download" attribute has no effect without an "href".',
     },
   ],
-  form: [
-    {
-      attr: "enctype",
-      when: (node) => {
-        const method = (getAttrValue(node, "method") || "get").toLowerCase();
-        return method !== "post";
-      },
-      message:
-        'The "enctype" attribute is only relevant when method is "post".',
-    },
-  ],
 };
 
 /**
@@ -107,7 +97,7 @@ module.exports = {
    * @param {any} context
    */
   create(context) {
-    return {
+    return createVisitors(context, {
       /**
        * @param {Tag} node
        */
@@ -133,7 +123,7 @@ module.exports = {
         }
       },
       /**
-       * @param {any} node
+       * @param {ScriptTag} node
        */
       ScriptTag(node) {
         const scriptCheckers = checkersByTag.script;
@@ -156,6 +146,6 @@ module.exports = {
           }
         }
       },
-    };
+    });
   },
 };
diff --git a/packages/eslint-plugin/lib/rules/utils/node.js b/packages/eslint-plugin/lib/rules/utils/node.js
index 962ebc31..f2909d24 100644
--- a/packages/eslint-plugin/lib/rules/utils/node.js
+++ b/packages/eslint-plugin/lib/rules/utils/node.js
@@ -18,7 +18,7 @@ function findAttr(node, key) {
 }
 
 /**
- * @param {Tag} node
+ * @param {Tag | ScriptTag} node
  * @param {string} attrName
  * @returns {boolean}
  */
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index 03a1ae0e..71016b05 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -36,11 +36,6 @@ ruleTester.run("no-ineffective-attrs", rule, {
     {
       code: '<a href="file.pdf" download>Download</a>',
     },
-
-    // Valid form with POST method and enctype
-    {
-      code: '<form method="post" enctype="multipart/form-data"></form>',
-    },
   ],
   invalid: [
     // Invalid multiple on text input
@@ -119,36 +114,27 @@ ruleTester.run("no-ineffective-attrs", rule, {
         },
       ],
     },
-    // Invalid enctype on GET form
+  ],
+});
+
+templateRuleTester.run("[template] no-ineffective-attrs", rule, {
+  valid: [
     {
-      code: '<form method="get" enctype="multipart/form-data"></form>',
-      errors: [
-        {
-          messageId: "ineffective",
-          data: {
-            message:
-              'The "enctype" attribute is only relevant when method is "post".',
-          },
-        },
-      ],
+      code: `html\`<input type="email" multiple>\``,
     },
-    // Invalid enctype on default method form
+  ],
+  invalid: [
     {
-      code: '<form enctype="multipart/form-data"></form>',
+      code: 'html`<input type="text" multiple>`',
       errors: [
         {
           messageId: "ineffective",
           data: {
             message:
-              'The "enctype" attribute is only relevant when method is "post".',
+              'The "multiple" attribute has no effect on this input type.',
           },
         },
       ],
     },
   ],
 });
-
-templateRuleTester.run("[template] no-ineffective-attrs", rule, {
-  valid: [],
-  invalid: [],
-});

From 88eed22e57d72f8918cabcfc8387a45718e73267 Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 18:45:08 +0900
Subject: [PATCH 08/12] feat: add cases

---
 docs/rules/no-ineffective-attrs.md            |  16 --
 .../lib/rules/no-ineffective-attrs.js         |  14 ++
 .../tests/rules/no-ineffective-attrs.test.js  | 163 ++++++++++++++++++
 3 files changed, 177 insertions(+), 16 deletions(-)

diff --git a/docs/rules/no-ineffective-attrs.md b/docs/rules/no-ineffective-attrs.md
index 2e47ab87..ea09eca1 100644
--- a/docs/rules/no-ineffective-attrs.md
+++ b/docs/rules/no-ineffective-attrs.md
@@ -28,16 +28,8 @@ Examples of **incorrect** code for this rule:
   console.log("hello");
 </script>
 
-<!-- value attribute has no effect on textarea -->
-<textarea value="default">actual content</textarea>
-
 <!-- download needs href to work -->
 <a download="file.pdf">Download</a>
-
-<!-- enctype only applies to POST forms -->
-<form method="get" enctype="multipart/form-data">
-  <input type="text" name="query" />
-</form>
 ```
 
 Examples of **correct** code for this rule:
@@ -52,14 +44,6 @@ Examples of **correct** code for this rule:
 <!-- defer works with external scripts -->
 <script defer src="script.js"></script>
 
-<!-- textarea uses content, not value attribute -->
-<textarea>default content</textarea>
-
 <!-- download works when href is present -->
 <a href="file.pdf" download="file.pdf">Download</a>
-
-<!-- enctype applies to POST forms -->
-<form method="post" enctype="multipart/form-data">
-  <input type="file" name="upload" />
-</form>
 ```
diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index fa1870c9..a2277ad8 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -72,6 +72,20 @@ const checkersByTag = {
       message: 'The "download" attribute has no effect without an "href".',
     },
   ],
+  audio: [
+    {
+      attr: "controlslist",
+      when: (node) => !hasAttr(node, "controls"),
+      message: 'The "controlslist" attribute has no effect without "controls".',
+    },
+  ],
+  video: [
+    {
+      attr: "controlslist",
+      when: (node) => !hasAttr(node, "controls"),
+      message: 'The "controlslist" attribute has no effect without "controls".',
+    },
+  ],
 };
 
 /**
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index 71016b05..9a616f48 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -36,6 +36,16 @@ ruleTester.run("no-ineffective-attrs", rule, {
     {
       code: '<a href="file.pdf" download>Download</a>',
     },
+
+    // Valid audio with controls and controlslist
+    {
+      code: '<audio controls controlslist="nodownload"></audio>',
+    },
+
+    // Valid video with controls and controlslist
+    {
+      code: '<video controls controlslist="nofullscreen"></video>',
+    },
   ],
   invalid: [
     // Invalid multiple on text input
@@ -114,16 +124,80 @@ ruleTester.run("no-ineffective-attrs", rule, {
         },
       ],
     },
+    // Invalid controlslist on audio without controls
+    {
+      code: '<audio controlslist="nodownload"></audio>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "controlslist" attribute has no effect without "controls".',
+          },
+        },
+      ],
+    },
+    // Invalid controlslist on video without controls
+    {
+      code: '<video controlslist="nofullscreen"></video>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "controlslist" attribute has no effect without "controls".',
+          },
+        },
+      ],
+    },
   ],
 });
 
 templateRuleTester.run("[template] no-ineffective-attrs", rule, {
   valid: [
+    // Valid input types for multiple attribute
     {
       code: `html\`<input type="email" multiple>\``,
     },
+    {
+      code: `html\`<input type="file" multiple>\``,
+    },
+    {
+      code: `html\`<select multiple></select>\``,
+    },
+
+    // Valid file input with accept
+    {
+      code: `html\`<input type="file" accept=".jpg,.png">\``,
+    },
+
+    // Valid script with src and defer
+    {
+      code: `html\`<script src="script.js" defer></script>\``,
+    },
+
+    // Valid script with src and async
+    {
+      code: `html\`<script src="script.js" async></script>\``,
+    },
+
+    // Valid anchor with href and download
+    {
+      code: `html\`<a href="file.pdf" download>Download</a>\``,
+    },
+
+    // Valid audio with controls and controlslist
+    {
+      code: `html\`<audio controls controlslist="nodownload"></audio>\``,
+    },
+
+    // Valid video with controls and controlslist
+    {
+      code: `html\`<video controls controlslist="nofullscreen"></video>\``,
+    },
   ],
   invalid: [
+    // Invalid multiple on text input
     {
       code: 'html`<input type="text" multiple>`',
       errors: [
@@ -136,5 +210,94 @@ templateRuleTester.run("[template] no-ineffective-attrs", rule, {
         },
       ],
     },
+    // Invalid multiple on checkbox
+    {
+      code: `html\`<input type="checkbox" multiple>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "multiple" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid accept on non-file input
+    {
+      code: `html\`<input type="text" accept=".jpg">\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "accept" attribute has no effect unless input type is "file".',
+          },
+        },
+      ],
+    },
+    // Invalid defer on inline script
+    {
+      code: `html\`<script defer></script>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message: 'The "defer" attribute has no effect on inline scripts.',
+          },
+        },
+      ],
+    },
+    // Invalid async on inline script
+    {
+      code: `html\`<script async></script>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message: 'The "async" attribute has no effect on inline scripts.',
+          },
+        },
+      ],
+    },
+    // Invalid download without href
+    {
+      code: `html\`<a download>Download</a>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "download" attribute has no effect without an "href".',
+          },
+        },
+      ],
+    },
+    // Invalid controlslist on audio without controls
+    {
+      code: `html\`<audio controlslist="nodownload"></audio>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "controlslist" attribute has no effect without "controls".',
+          },
+        },
+      ],
+    },
+    // Invalid controlslist on video without controls
+    {
+      code: `html\`<video controlslist="nofullscreen"></video>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "controlslist" attribute has no effect without "controls".',
+          },
+        },
+      ],
+    },
   ],
 });

From 168f17bd95a99f08e61a6c2732b0a56c10f7890c Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 18:46:25 +0900
Subject: [PATCH 09/12] Update .cspell.json

---
 .cspell.json | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.cspell.json b/.cspell.json
index c884c750..9c0cf4a5 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -59,6 +59,9 @@
     "contenteditable",
     "nbsb",
     "endl",
-    "cout"
+    "cout",
+    "nodownload",
+    "nofullscreen",
+    "controlslist"
   ]
 }

From b392efce5535af7c659671517f92de751fa5f90f Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 18:51:52 +0900
Subject: [PATCH 10/12] implement

---
 docs/rules/no-ineffective-attrs.md            |  33 +++-
 .../lib/rules/no-ineffective-attrs.js         |   8 +
 .../tests/rules/no-ineffective-attrs.test.js  | 150 ++++++++++++++++++
 3 files changed, 189 insertions(+), 2 deletions(-)

diff --git a/docs/rules/no-ineffective-attrs.md b/docs/rules/no-ineffective-attrs.md
index ea09eca1..eda2738b 100644
--- a/docs/rules/no-ineffective-attrs.md
+++ b/docs/rules/no-ineffective-attrs.md
@@ -20,30 +20,59 @@ Examples of **incorrect** code for this rule:
 <!-- multiple has no effect on text inputs -->
 <input type="text" multiple />
 
+<!-- multiple has no effect on checkbox inputs -->
+<input type="checkbox" multiple />
+
 <!-- accept only works with file inputs -->
 <input type="text" accept=".jpg,.png" />
 
+<!-- readonly has no effect on checkbox inputs -->
+<input type="checkbox" readonly />
+
+<!-- readonly has no effect on file inputs -->
+<input type="file" readonly />
+
 <!-- defer has no effect on inline scripts -->
 <script defer>
   console.log("hello");
 </script>
 
+<!-- async has no effect on inline scripts -->
+<script async>
+  console.log("hello");
+</script>
+
 <!-- download needs href to work -->
 <a download="file.pdf">Download</a>
+
+<!-- controlslist needs controls to work -->
+<audio controlslist="nodownload"></audio>
+<video controlslist="nofullscreen"></video>
 ```
 
 Examples of **correct** code for this rule:
 
 ```html
-<!-- multiple works with file inputs -->
+<!-- multiple works with email and file inputs -->
+<input type="email" multiple />
 <input type="file" multiple />
+<select multiple></select>
 
 <!-- accept works with file inputs -->
 <input type="file" accept=".jpg,.png" />
 
-<!-- defer works with external scripts -->
+<!-- readonly works with text and password inputs -->
+<input type="text" readonly />
+<input type="password" readonly />
+
+<!-- defer and async work with external scripts -->
 <script defer src="script.js"></script>
+<script async src="script.js"></script>
 
 <!-- download works when href is present -->
 <a href="file.pdf" download="file.pdf">Download</a>
+
+<!-- controlslist works when controls is present -->
+<audio controls controlslist="nodownload"></audio>
+<video controls controlslist="nofullscreen"></video>
 ```
diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index a2277ad8..60abbc84 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -52,6 +52,14 @@ const checkersByTag = {
       message:
         'The "accept" attribute has no effect unless input type is "file".',
     },
+    {
+      attr: "readonly",
+      when: (node) => {
+        const type = getAttrValue(node, "type") || "text";
+        return ["checkbox", "radio", "file", "range", "color"].includes(type);
+      },
+      message: 'The "readonly" attribute has no effect on this input type.',
+    },
   ],
   script: [
     {
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index 9a616f48..0b80b2bc 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -22,6 +22,16 @@ ruleTester.run("no-ineffective-attrs", rule, {
       code: '<input type="file" accept=".jpg,.png">',
     },
 
+    // Valid text input with readonly
+    {
+      code: '<input type="text" readonly>',
+    },
+
+    // Valid password input with readonly
+    {
+      code: '<input type="password" readonly>',
+    },
+
     // Valid script with src and defer
     {
       code: '<script src="script.js" defer></script>',
@@ -150,6 +160,71 @@ ruleTester.run("no-ineffective-attrs", rule, {
         },
       ],
     },
+    // Invalid readonly on checkbox input
+    {
+      code: '<input type="checkbox" readonly>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on radio input
+    {
+      code: '<input type="radio" readonly>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on file input
+    {
+      code: '<input type="file" readonly>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on range input
+    {
+      code: '<input type="range" readonly>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on color input
+    {
+      code: '<input type="color" readonly>',
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
   ],
 });
 
@@ -171,6 +246,16 @@ templateRuleTester.run("[template] no-ineffective-attrs", rule, {
       code: `html\`<input type="file" accept=".jpg,.png">\``,
     },
 
+    // Valid text input with readonly
+    {
+      code: `html\`<input type="text" readonly>\``,
+    },
+
+    // Valid password input with readonly
+    {
+      code: `html\`<input type="password" readonly>\``,
+    },
+
     // Valid script with src and defer
     {
       code: `html\`<script src="script.js" defer></script>\``,
@@ -299,5 +384,70 @@ templateRuleTester.run("[template] no-ineffective-attrs", rule, {
         },
       ],
     },
+    // Invalid readonly on checkbox input
+    {
+      code: `html\`<input type="checkbox" readonly>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on radio input
+    {
+      code: `html\`<input type="radio" readonly>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on file input
+    {
+      code: `html\`<input type="file" readonly>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on range input
+    {
+      code: `html\`<input type="range" readonly>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
+    // Invalid readonly on color input
+    {
+      code: `html\`<input type="color" readonly>\``,
+      errors: [
+        {
+          messageId: "ineffective",
+          data: {
+            message:
+              'The "readonly" attribute has no effect on this input type.',
+          },
+        },
+      ],
+    },
   ],
 });

From 547bc1acc564bdf76fcabf8c85691a2d03508dcb Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 18:53:14 +0900
Subject: [PATCH 11/12] Update no-ineffective-attrs.js

---
 packages/eslint-plugin/lib/rules/no-ineffective-attrs.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index 60abbc84..352816fe 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -115,9 +115,6 @@ module.exports = {
     type: "problem",
   },
   defaultOptions: [],
-  /**
-   * @param {any} context
-   */
   create(context) {
     return createVisitors(context, {
       /**

From 286ba84525f393aded7972cfcbd1c01e7315f2f6 Mon Sep 17 00:00:00 2001
From: YeonJuan <yeonjuan93@naver.com>
Date: Sat, 9 Aug 2025 18:57:37 +0900
Subject: [PATCH 12/12] update

---
 .../lib/rules/no-ineffective-attrs.js            | 16 +++++++++++++++-
 .../tests/rules/no-ineffective-attrs.test.js     |  6 ++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
index 352816fe..a52f3115 100644
--- a/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
+++ b/packages/eslint-plugin/lib/rules/no-ineffective-attrs.js
@@ -5,7 +5,7 @@
  */
 
 const { RULE_CATEGORY } = require("../constants");
-const { hasAttr } = require("./utils/node");
+const { hasAttr, hasTemplate, findAttr } = require("./utils/node");
 const { createVisitors } = require("./utils/visitors");
 
 /**
@@ -21,6 +21,17 @@ function getAttrValue(node, attrName) {
   return attr.value.value;
 }
 
+/**
+ * @param {Tag | ScriptTag} node
+ * @param {string} attrName
+ * @returns {boolean}
+ */
+function isTemplateValueAttr(node, attrName) {
+  const attr = findAttr(node, attrName);
+  if (!attr || !attr.value) return false;
+  return hasTemplate(attr.value);
+}
+
 /**
  * @type {Record<string, AttributeChecker[]>}
  */
@@ -46,6 +57,9 @@ const checkersByTag = {
     {
       attr: "accept",
       when: (node) => {
+        if (isTemplateValueAttr(node, "type")) {
+          return false;
+        }
         const type = getAttrValue(node, "type") || "text";
         return type !== "file";
       },
diff --git a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
index 0b80b2bc..ddde93a0 100644
--- a/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
+++ b/packages/eslint-plugin/tests/rules/no-ineffective-attrs.test.js
@@ -245,11 +245,17 @@ templateRuleTester.run("[template] no-ineffective-attrs", rule, {
     {
       code: `html\`<input type="file" accept=".jpg,.png">\``,
     },
+    {
+      code: `html\`<input type="\${type}" accept=".jpg,.png">\``,
+    },
 
     // Valid text input with readonly
     {
       code: `html\`<input type="text" readonly>\``,
     },
+    {
+      code: `html\`<input type="\${type}" readonly>\``,
+    },
 
     // Valid password input with readonly
     {