Port autofix for template-simple-unless

ember-template-lint's simple-unless fixes two of the four violation
types; the autofix was lost when the rule was extracted. Restores it
using text-based replacement (this rule does not have access to
ember-template-recast):

- withHelper: `{{unless cond}}` -> `{{if (not cond)}}`, with two De
  Morgan special-cases:
  - `{{unless (not x)}}` -> `{{if x}}` (unwrap the not)
  - `{{unless (not x y)}}` -> `{{if (or x y)}}` (multi-arg `not` is
    true only when all args are falsy)
- followingElseBlock: `{{#unless cond}}A{{else}}B{{/unless}}` ->
  `{{#if cond}}B{{else}}A{{/if}}` (body/inverse swap)

The followingElseIfBlock (`{{#unless}}...{{else if}}`) and
asElseUnlessBlock (`{{#if}}...{{else unless}}`) cases remain
unfixable, also matching upstream.

The body-swap fixer slices sourceCode.text between node.program.range
and node.inverse.range and reassembles with a hardcoded `{{else}}`
separator, which normalizes whitespace around `{{else}}`.

Author: johanrd

README.md

@@ -283,7 +283,7 @@ rules in templates can be disabled with eslint directives with mustache or html
 | [template-require-valid-named-block-naming-format](docs/rules/template-require-valid-named-block-naming-format.md) | require valid named block naming format                                      |    | 🔧 |    |
 | [template-self-closing-void-elements](docs/rules/template-self-closing-void-elements.md)                           | require self-closing on void elements                                        |    | 🔧 |    |
 | [template-simple-modifiers](docs/rules/template-simple-modifiers.md)                                               | require simple modifier syntax                                               |    |    |    |
-| [template-simple-unless](docs/rules/template-simple-unless.md)                                                     | require simple conditions in unless blocks                                   |    |    |    |
+| [template-simple-unless](docs/rules/template-simple-unless.md)                                                     | require simple conditions in unless blocks                                   |    | 🔧 |    |
 | [template-sort-invocations](docs/rules/template-sort-invocations.md)                                               | require sorted attributes and modifiers                                      |    |    |    |
 | [template-splat-attributes-only](docs/rules/template-splat-attributes-only.md)                                     | disallow ...spread other than ...attributes                                  |    |    |    |
 | [template-style-concatenation](docs/rules/template-style-concatenation.md)                                         | disallow string concatenation in inline styles                               |    |    |    |

docs/rules/template-simple-unless.md

@@ -1,5 +1,7 @@
 # ember/template-simple-unless
 
+🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
 <!-- end auto-generated rule header -->
 
 Require simple conditions in `{{#unless}}` blocks. Complex expressions should use `{{#if}}` with negation instead.

lib/rules/template-simple-unless.js

@@ -16,6 +16,7 @@ module.exports = {
       url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-simple-unless.md',
       templateMode: 'both',
     },
+    fixable: 'code',
     schema: [
       {
         type: 'object',
@@ -58,6 +59,64 @@ module.exports = {
       return false;
     }
 
+    /**
+     * Build a fixer for the _withHelper case.
+     * Converts `unless` to `if` and wraps the first param with `(not ...)`.
+     * Special-cases when the first param is already `(not ...)`:
+     *   - single arg: `unless (not x)` → `if x`
+     *   - multiple args: `unless (not x y)` → `if (or x y)`
+     */
+    function buildWithHelperFix(node) {
+      return function fix(fixer) {
+        const nodeText = sourceCode.getText(node);
+        const firstParam = node.params[0];
+        const firstParamText = sourceCode.getText(firstParam);
+
+        // Replace 'unless' with 'if' in the keyword
+        let newText = nodeText.replace(/^({{#?)unless/, '$1if');
+
+        if (firstParam.type === 'GlimmerSubExpression' && firstParam.path?.original === 'not') {
+          // Special case: first param is (not ...)
+          if (firstParam.params.length > 1) {
+            // (not x y) → (or x y)
+            const innerParamsText = firstParam.params.map((p) => sourceCode.getText(p)).join(' ');
+            newText = newText.replace(firstParamText, `(or ${innerParamsText})`);
+          } else {
+            // (not x) → x — unwrap the not
+            const innerText = sourceCode.getText(firstParam.params[0]);
+            newText = newText.replace(firstParamText, innerText);
+          }
+        } else {
+          // Wrap with (not ...)
+          newText = newText.replace(firstParamText, `(not ${firstParamText})`);
+        }
+
+        // Also fix the closing tag for block statements
+        if (node.type === 'GlimmerBlockStatement') {
+          newText = newText.replace(/{{\/unless}}$/, '{{/if}}');
+        }
+
+        return fixer.replaceText(node, newText);
+      };
+    }
+
+    /**
+     * Build a fixer for the _followingElseBlock case (simple else, no else-if).
+     * Swaps body/inverse and changes unless→if.
+     */
+    function buildFollowingElseBlockFix(node) {
+      return function fix(fixer) {
+        const programStart = node.program.range[0];
+        const bodyText = sourceCode.text.slice(programStart, node.program.range[1]);
+        const inverseText = sourceCode.text.slice(node.inverse.range[0], node.inverse.range[1]);
+        const openingTag = sourceCode.text
+          .slice(node.range[0], programStart)
+          .replace(/^({{#)unless/, '$1if');
+        // Result shape: {{#if cond}}inverse{{else}}body{{/if}}
+        return fixer.replaceText(node, `${openingTag}${inverseText}{{else}}${bodyText}{{/if}}`);
+      };
+    }
+
     function checkWithHelper(node) {
       let helperCount = 0;
       let nextParams = node.params || [];
@@ -78,6 +137,7 @@ module.exports = {
                 data: {
                   message: `Using {{unless}} in combination with other helpers should be avoided. MaxHelpers: ${maxHelpers}`,
                 },
+                fix: buildWithHelperFix(node),
               });
               return;
             }
@@ -89,6 +149,7 @@ module.exports = {
                 data: {
                   message: `Using {{unless}} in combination with other helpers should be avoided. Allowed helper${allowlist.length > 1 ? 's' : ''}: ${allowlist}`,
                 },
+                fix: buildWithHelperFix(node),
               });
               return;
             }
@@ -100,6 +161,7 @@ module.exports = {
                 data: {
                   message: `Using {{unless}} in combination with other helpers should be avoided. Restricted helper${denylist.length > 1 ? 's' : ''}: ${denylist}`,
                 },
+                fix: buildWithHelperFix(node),
               });
               return;
             }
@@ -128,19 +190,21 @@ module.exports = {
           if (isUnless(node)) {
             // Check for {{#unless}}...{{else if}}
             if (nodeInverse.body[0] && isIf(nodeInverse.body[0])) {
+              // Not fixable (ETL: _followingElseIfBlock, isFixable=false)
               context.report({
                 node: node.program || node,
                 messageId: 'followingElseBlock',
               });
             } else {
-              // {{#unless}}...{{else}}
+              // {{#unless}}...{{else}} — fixable
               context.report({
                 node: node.program || node,
                 messageId: 'followingElseBlock',
+                fix: buildFollowingElseBlockFix(node),
               });
             }
           } else if (isElseUnlessBlock(nodeInverse.body[0])) {
-            // {{#if}}...{{else unless}}
+            // {{#if}}...{{else unless}} — not fixable (ETL: isFixable=false)
             context.report({
               node: nodeInverse.body[0],
               messageId: 'asElseUnlessBlock',