flatlint 1.26.0 → 1.28.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2025.01.08, v1.28.0
+
+feature:
+- b1e6b43 remove-useless-comma: improve
+- 3ebb93d add-missing-semicolon: improve
+
+2025.01.08, v1.27.0
+
+feature:
+- a6b1991 flatlint: multiple fixes in one source
+
 2025.01.07, v1.26.0
 
 feature:

package/lib/compare/collect-expression.js

@@ -1,5 +1,6 @@
 import {
     closeRoundBrace,
+    comma,
     openRoundBrace,
     semicolon,
 } from '#types';
@@ -15,6 +16,9 @@ export const collectExpression = ({currentTokenIndex, tokens, nextTemplateToken
         if (equal(token, semicolon))
             break;
         
+        if (equal(token, comma))
+            break;
+        
         if (equal(token, nextTemplateToken))
             break;
         

package/lib/compare/compare.js

@@ -3,6 +3,8 @@ import {
     isTemplateArgsToken,
     isTemplateArrayToken,
     isTemplateExpressionToken,
+    OK,
+    NOT_OK,
 } from '#types';
 import {collectArray} from './collect-array.js';
 import {collectExpression} from './collect-expression.js';
@@ -15,7 +17,7 @@ import {
     equalStr,
 } from './equal.js';
 
-export const compare = (source, template) => {
+export const compare = (source, template, {index = 0} = {}) => {
     const templateTokens = prepare(template);
     const tokens = prepare(source);
     
@@ -25,9 +27,10 @@ export const compare = (source, template) => {
     let start = 0;
     let end = 0;
     let delta = 0;
-    let skip = 0;
     
-    for (let index = 0; index < n; index++) {
+    for (; index < n; index++) {
+        let skip = 0;
+        
         for (let templateIndex = 0; templateIndex < templateTokensLength; templateIndex++) {
             let currentTokenIndex = index + templateIndex - skip;
             
@@ -58,7 +61,7 @@ export const compare = (source, template) => {
                     nextTemplateToken: templateTokens[templateIndex + 1],
                 });
                 
-                if (n === indexOfExpressionEnd) {
+                if (indexOfExpressionEnd >= n - 1) {
                     end = indexOfExpressionEnd;
                     continue;
                 }
@@ -90,10 +93,14 @@ export const compare = (source, template) => {
         }
         
         if (isEqual)
-            return [true, start, ++end];
+            return [
+                OK,
+                start,
+                ++end,
+            ];
     }
     
-    return [false];
+    return [NOT_OK];
 };
 
 const comparators = [

package/lib/compare/values.js

@@ -0,0 +1,77 @@
+import {traverse} from '#traverser';
+import {prepare} from '#parser';
+import {
+    is,
+    isTemplateArgs,
+    isTemplateArray,
+    isTemplateExpression,
+} from '#types';
+import {collectArray} from './collect-array.js';
+import {collectExpression} from './collect-expression.js';
+import {collectArgs} from './collect-args.js';
+
+const {entries} = Object;
+
+export function findVarsWays(tokens) {
+    const ways = {};
+    
+    traverse(tokens, {
+        Identifier({value, index}) {
+            if (is(value))
+                ways[value] = index;
+        },
+        StringLiteral({value, index}) {
+            if (is(value))
+                ways[value] = index;
+        },
+    });
+    
+    return ways;
+}
+
+export function getValues(tokens, waysFrom) {
+    const values = {};
+    
+    for (const [name, index] of entries(waysFrom)) {
+        let end = index;
+        let ok = true;
+        
+        if (isTemplateArray(name))
+            [ok, end] = collectArray({
+                currentTokenIndex: index,
+                tokens,
+            });
+        else if (isTemplateExpression(name))
+            end = collectExpression({
+                currentTokenIndex: index,
+                tokens,
+            });
+        else if (isTemplateArgs(name))
+            [ok, end] = collectArgs({
+                currentTokenIndex: index,
+                tokens,
+            });
+        
+        if (!ok) {
+            values[name] = [];
+            continue;
+        }
+        
+        values[name] = tokens.slice(index, end + 1);
+    }
+    
+    return values;
+}
+
+export function setValues({to, waysTo, values}) {
+    for (const [name, index] of entries(waysTo)) {
+        to.splice(index, 1, ...values[name]);
+    }
+}
+
+export function getCurrentValues({from, start, end, tokens}) {
+    const current = tokens.slice(start, end);
+    const waysFrom = findVarsWays(prepare(from));
+    
+    return getValues(current, waysFrom);
+}

package/lib/flatlint.js

@@ -1,11 +1,7 @@
 import {loadPlugins} from '@putout/engine-loader';
 import {parse} from '#parser';
 import {run} from '#runner';
-
-const getValue = (token) => token.value;
-const print = (tokens) => tokens
-    .map(getValue)
-    .join('');
+import {print} from '#printer';
 
 export function lint(source, overrides = {}) {
     const {fix = true, plugins: pluginNames = []} = overrides;

package/lib/plugins/add-missing-round-braces/index.js

@@ -1,9 +1,22 @@
-import {closeRoundBrace} from '#types';
+import {
+    closeRoundBrace,
+    isPunctuator,
+} from '#types';
 
 export const report = () => 'Add missing round braces';
 
 export const match = () => ({
-    '__a(__args': (vars, path) => !path.isNextPunctuator(closeRoundBrace),
+    '__a(__args': (vars, path) => {
+        if (path.isCurrentPunctuator(closeRoundBrace))
+            return false;
+        
+        for (const token of path.getAllNext()) {
+            if (isPunctuator(token, closeRoundBrace))
+                return false;
+        }
+        
+        return true;
+    },
 });
 
 export const replace = () => ({

package/lib/plugins/add-missing-semicolon/index.js

@@ -17,7 +17,13 @@ export const replace = () => ({
 });
 
 function check(vars, path) {
-    if (path.isEndsWithPunctuator(comma))
+    if (path.isNextPunctuator(comma))
+        return false;
+    
+    if (path.isNextPunctuator(semicolon))
+        return false;
+    
+    if (path.isPrevIdentifier('function'))
         return false;
     
     for (const token of path.getAllNext()) {

package/lib/plugins/convert-comma-to-semicolon/index.js

@@ -1,4 +1,18 @@
+import {colon, isPunctuator} from '#types';
+
 export const report = () => 'Use semicolon instead of trailing comma';
+export const match = () => ({
+    '__a(__args),': (vars, path) => {
+        for (const token of path.getAllPrev()) {
+            if (isPunctuator(token, colon))
+                return false;
+        }
+        
+        return true;
+    },
+});
+
 export const replace = () => ({
     'const __a = __b,': 'const __a = __b;',
+    '__a(__args),': '__a(__args);',
 });

package/lib/plugins/{remove-useless-coma → remove-useless-comma}/index.js

@@ -15,4 +15,5 @@ export const match = () => ({
 
 export const replace = () => ({
     '__a(__args) {},': '__a(__args) {}',
+    '__a(),': '__a()',
 });

package/lib/plugins.js

@@ -2,20 +2,22 @@ import * as wrapAssignmentInParens from './plugins/wrap-assignment-in-parens/ind
 import * as addMissingRoundBraces from './plugins/add-missing-round-braces/index.js';
 import * as addMissingSquireBrace from './plugins/add-missing-square-brace/index.js';
 import * as addMissingQuote from './plugins/add-missing-quote/index.js';
+import * as addMissingSemicolon from './plugins/add-missing-semicolon/index.js';
 import * as convertCommaToSemicolon from './plugins/convert-comma-to-semicolon/index.js';
 import * as convertFromToRequire from './plugins/convert-from-to-require/index.js';
 import * as removeUselessRoundBrace from './plugins/remove-useless-round-brace/index.js';
+import * as removeUselessComma from './plugins/remove-useless-comma/index.js';
 import * as addConstToExport from './plugins/add-const-to-export/index.js';
-import * as addMissingSemicolon from './plugins/add-missing-semicolon/index.js';
 
 export const plugins = [
     ['wrap-assignment-in-parens', wrapAssignmentInParens],
     ['add-missing-round-braces', addMissingRoundBraces],
     ['add-missing-squire-brace', addMissingSquireBrace],
-    ['add-missing-quote', addMissingQuote],
     ['add-missing-semicolon', addMissingSemicolon],
+    ['add-missing-quote', addMissingQuote],
     ['add-const-to-export', addConstToExport],
     ['convert-comma-to-semicolon', convertCommaToSemicolon],
     ['convert-from-to-require', convertFromToRequire],
     ['remove-useless-round-brace', removeUselessRoundBrace],
+    ['remove-useless-comma', removeUselessComma],
 ];

package/lib/printer/printer.js

@@ -0,0 +1,7 @@
+const getValue = (token) => token.value;
+
+export const print = (tokens) => {
+    return tokens
+        .map(getValue)
+        .join('');
+};

package/lib/runner/path.js

@@ -1,6 +1,13 @@
-import {isNewLine, isPunctuator} from '#types';
+import {
+    isIdentifier,
+    isNewLine,
+    isPunctuator,
+} from '#types';
 
 export const createPath = ({tokens, start, end}) => ({
+    tokens,
+    start,
+    end,
     getAllPrev: createGetAllPrev({
         tokens,
         start,
@@ -13,29 +20,34 @@ export const createPath = ({tokens, start, end}) => ({
         tokens,
         end,
     }),
-    isEndsWithPunctuator: createIsCurrentPunctuator({
+    isPrevIdentifier: createIsPrevIdentifier({
         tokens,
-        end,
+        start,
     }),
-    isCurrentPunctuator: createIsCurrentPunctuator({
+    isCurrentPunctuator: createIsNextPunctuator({
         tokens,
-        end,
+        end: end - 1,
     }),
 });
 
-const createIsCurrentPunctuator = ({tokens, end}) => (punctuator) => {
-    const current = tokens[end - 1];
+const createIsNextPunctuator = ({tokens, end}) => (punctuator) => {
+    const current = tokens[end];
+    
+    if (!current)
+        return false;
     
     return isPunctuator(current, punctuator);
 };
 
-const createIsNextPunctuator = ({tokens, end}) => (punctuator) => {
-    const current = tokens[end];
+const createIsPrevIdentifier = ({tokens, start}) => (value) => {
+    const SPACE = 1;
+    const FUNCTION = 1;
+    const current = tokens[start - (FUNCTION + SPACE)];
     
     if (!current)
         return false;
     
-    return isPunctuator(current, punctuator);
+    return isIdentifier(current, value);
 };
 
 const createGetAllPrev = ({tokens, start}) => function*() {

package/lib/runner/replacer.js

@@ -1,17 +1,12 @@
 import debug from 'debug';
 import {compare} from '#compare';
 import {prepare} from '#parser';
-import {traverse} from '#traverser';
 import {
-    is,
-    isTemplateArgs,
-    isTemplateArray,
-    isTemplateExpression,
-} from '#types';
-import {collectArray} from '../compare/collect-array.js';
-import {collectExpression} from '../compare/collect-expression.js';
+    findVarsWays,
+    getCurrentValues,
+    setValues,
+} from '#compare/values';
 import {createPath} from './path.js';
-import {collectArgs} from '../compare/collect-args.js';
 
 const returns = (a) => () => a;
 const {entries} = Object;
@@ -20,125 +15,75 @@ const log = debug('flatlint');
 export const replace = (tokens, {fix, rule, plugin}) => {
     const places = [];
     let isFixed = false;
+    
     const match = plugin.match?.() ?? returns({});
     
-    for (let [from, to] of entries(plugin.replace())) {
-        const [ok, start, end] = compare(tokens, from);
-        
-        if (!ok)
-            continue;
-        
-        const values = getCurrentValues({
-            from,
-            start,
-            end,
-            tokens,
-        });
+    for (const [from, to] of entries(plugin.replace())) {
+        let index = 0;
         
-        const matchFn = match[from];
-        
-        if (matchFn) {
-            const is = matchFn(values, createPath({
-                tokens,
+        while (index < tokens.length - 1) {
+            const [ok, start, end] = compare(tokens, from, {
+                index,
+            });
+            
+            if (!ok)
+                break;
+            
+            const values = getCurrentValues({
+                from,
                 start,
                 end,
-            }));
+                tokens,
+            });
             
-            if (!is)
+            const matchFn = match[from];
+            
+            if (matchFn) {
+                const is = matchFn(values, createPath({
+                    tokens,
+                    start,
+                    end,
+                }));
+                
+                if (!is) {
+                    index = end;
+                    continue;
+                }
+            }
+            
+            if (fix) {
+                log(`${rule}: ${from} -> ${to}`);
+                
+                const preparedTo = prepare(to);
+                const waysTo = findVarsWays(preparedTo);
+                
+                setValues({
+                    values,
+                    waysTo,
+                    to: preparedTo,
+                });
+                
+                tokens.splice(start, end - start, ...preparedTo);
+                isFixed = true;
+                index = end;
+                
                 continue;
-        }
-        
-        if (fix) {
-            log(`${rule}: ${from} -> ${to}`);
-            to = prepare(to);
-            const waysTo = findVarsWays(to);
+            }
+            
+            const {line, column} = tokens[start];
+            const message = plugin.report();
             
-            setValues({
-                values,
-                waysTo,
-                to,
+            places.push({
+                rule,
+                message,
+                line,
+                column,
             });
             
-            tokens.splice(start, end - start, ...to);
-            isFixed = true;
-            continue;
+            index = end;
+            isFixed = false;
         }
-        
-        const {line, column} = tokens[start];
-        const message = plugin.report();
-        
-        places.push({
-            rule,
-            message,
-            line,
-            column,
-        });
     }
     
     return [isFixed, places];
 };
-
-function findVarsWays(tokens) {
-    const ways = {};
-    
-    traverse(tokens, {
-        Identifier({value, index}) {
-            if (is(value))
-                ways[value] = index;
-        },
-        StringLiteral({value, index}) {
-            if (is(value))
-                ways[value] = index;
-        },
-    });
-    
-    return ways;
-}
-
-function getValues(tokens, waysFrom) {
-    const values = {};
-    
-    for (const [name, index] of entries(waysFrom)) {
-        let end = index;
-        let ok = true;
-        
-        if (isTemplateArray(name))
-            [ok, end] = collectArray({
-                currentTokenIndex: index,
-                tokens,
-            });
-        else if (isTemplateExpression(name))
-            end = collectExpression({
-                currentTokenIndex: index,
-                tokens,
-            });
-        else if (isTemplateArgs(name))
-            [ok, end] = collectArgs({
-                currentTokenIndex: index,
-                tokens,
-            });
-        
-        if (!ok) {
-            values[name] = [];
-            continue;
-        }
-        
-        values[name] = tokens.slice(index, end + 1);
-    }
-    
-    return values;
-}
-
-function setValues({to, waysTo, values}) {
-    for (const [name, index] of entries(waysTo)) {
-        to.splice(index, 1, ...values[name]);
-    }
-}
-
-function getCurrentValues({from, start, end, tokens}) {
-    const current = tokens.slice(start, end);
-    
-    const waysFrom = findVarsWays(prepare(from));
-    
-    return getValues(current, waysFrom);
-}

package/lib/types/types.js

@@ -82,6 +82,7 @@ export const closeRoundBrace = Punctuator(')');
 export const closeSquareBrace = Punctuator(']');
 export const semicolon = Punctuator(';');
 export const comma = Punctuator(',');
+export const colon = Punctuator(':');
 
 export const OK = true;
 export const NOT_OK = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flatlint",
-  "version": "1.26.0",
+  "version": "1.28.0",
   "description": "JavaScript tokens-based linter",
   "main": "lib/flatlint.js",
   "type": "module",
@@ -17,12 +17,18 @@
     "#parser": {
       "default": "./lib/parser/parser.js"
     },
+    "#printer": {
+      "default": "./lib/printer/printer.js"
+    },
     "#traverser": {
       "default": "./lib/traverser/traverser.js"
     },
     "#compare": {
       "default": "./lib/compare/compare.js"
     },
+    "#compare/values": {
+      "default": "./lib/compare/values.js"
+    },
     "#runner": {
       "default": "./lib/runner/runner.js"
     },