less 4.6.7 → 4.8.0

package/lib/less/deprecation.js

@@ -17,10 +17,25 @@ const deprecations = {
         description: 'The ./ operator is deprecated.'
     },
     'variable-in-unknown-value': {
-        description: '@[ident] in custom property values is treated as literal text.'
+        description: '@variable in custom property values is treated as literal text.'
+    },
+    'variable-in-at-rule-prelude': {
+        description: 'A bare @variable in an at-rule prelude (e.g. @media @foo) is deprecated. Use @{variable} interpolation instead.'
+    },
+    'numeric-variable-name': {
+        description: 'Variable names beginning with a number are deprecated and will be removed in Less 5.x.'
+    },
+    'dash-only-variable-name': {
+        description: 'The dash-only variable names @- and @{-} are deprecated and will be removed in Less 5.x.'
+    },
+    'dash-only-mixin-name': {
+        description: 'The dash-only mixin names .-() and #-() are deprecated and will be removed in Less 5.x.'
+    },
+    'dynamic-charset': {
+        description: 'Dynamic @charset interpolation is deprecated and will be removed in Less 5.x.'
     },
     'property-in-unknown-value': {
-        description: '$[ident] in custom property values is treated as literal text.'
+        description: '$property in custom property values is treated as literal text.'
     },
     'js-eval': {
         description: 'Inline JavaScript evaluation (backtick expressions) is deprecated and will be removed in Less 5.x.'

package/lib/less/parser/parser-input.js

@@ -204,12 +204,23 @@ export default () => {
     /**
      * Permissive parsing. Ignores everything except matching {} [] () and quotes
      * until matching token (outside of blocks)
+     *
+     * @param {string|RegExp} tok - stop token
+     * @param {boolean} [detectBareVar] - when set, also record the position of the
+     *   first bare `@variable` reference (not `@{interpolation}`) that appears at
+     *   PAREN depth 0 — i.e. a structural reference, not a declaration value inside
+     *   `(...)`. Reuses this single pass (which already skips strings/comments) so
+     *   callers don't re-scan the text. Exposed as `.bareVarIndex` on the returned
+     *   group array (or null). `[...]`/`{...}` do NOT shield a reference — only
+     *   `(...)` (a declaration-value group) does.
      */
-    parserInput.$parseUntil = tok => {
+    parserInput.$parseUntil = (tok, detectBareVar) => {
         let quote = '';
         let returnVal = null;
         let inComment = false;
         let blockDepth = 0;
+        let parenDepth = 0;
+        let bareVarIndex = null;
         const blockStack = [];
         const parseGroups = [];
         const length = input.length;
@@ -249,6 +260,12 @@ export default () => {
                     i++;
                     continue;
                 }
+                if (detectBareVar && bareVarIndex === null && nextChar === '@' && parenDepth === 0) {
+                    // A bare `@ident` (not `@{interpolation}`) outside any `(...)` —
+                    // a structural reference. Strings/comments are already skipped above.
+                    const after = input.charAt(i + 1);
+                    if (after && /[-\w]/.test(after)) { bareVarIndex = i; }
+                }
                 switch (nextChar) {
                     case '\\':
                         i++;
@@ -284,6 +301,7 @@ export default () => {
                     case '(':
                         blockStack.push(')');
                         blockDepth++;
+                        parenDepth++;
                         break;
                     case '[':
                         blockStack.push(']');
@@ -295,6 +313,7 @@ export default () => {
                         const expected = blockStack.pop();
                         if (nextChar === expected) {
                             blockDepth--;
+                            if (nextChar === ')' && parenDepth > 0) { parenDepth--; }
                         } else {
                             // move the parser to the error and return expected
                             skipWhitespace(i - startPos);
@@ -310,6 +329,7 @@ export default () => {
             }
         } while (loop);
 
+        if (Array.isArray(returnVal)) { returnVal.bareVarIndex = bareVarIndex; }
         return returnVal ? returnVal : null;
     }
 

package/lib/less/parser/parser.js

@@ -62,6 +62,10 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
 
     const deprecationHandler = new DeprecationHandler();
 
+    // Tracks `${deprecationId}@${index}` pairs already warned about, so a source
+    // position that gets re-parsed via parser backtracking only warns once.
+    const warnedDeprecations = new Set();
+
     /**
      * @param {string} msg
      * @param {number} index
@@ -71,6 +75,11 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
     function warn(msg, index, type, deprecationId) {
         if (context.quiet) { return; }
         if (deprecationId && context.quietDeprecations) { return; }
+        if (deprecationId) {
+            const key = `${deprecationId}@${index ?? parserInput.i}`;
+            if (warnedDeprecations.has(key)) { return; }
+            warnedDeprecations.add(key);
+        }
         if (deprecationId && !deprecationHandler.shouldWarn(deprecationId)) { return; }
 
         logger.warn(
@@ -86,6 +95,75 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
         );
     }
 
+    /**
+     * Warn that a bare `@variable` reference is being used in a non-value
+     * position (an at-rule prelude, name, or identifier), where it still
+     * resolves today but is deprecated in favour of `@{variable}` interpolation.
+     *
+     * @param {number} index - source position of the bare reference
+     */
+    function warnBareAtRuleVariable(index) {
+        warn('A bare @variable in an at-rule prelude is deprecated. Use @{variable} interpolation instead.', index, 'DEPRECATED', 'variable-in-at-rule-prelude');
+    }
+
+    /**
+     * Numeric-leading variable names are a Less extension rather than valid CSS
+     * identifier syntax. Keep accepting them through Less 4, but make the Less 5
+     * migration visible at every actual variable reference or definition.
+     *
+     * @param {string} name - either an @-prefixed name or the name inside @{...}
+     * @param {number} index - source position of the variable token
+     */
+    function warnNumericVariableName(name, index) {
+        if (/^(?:@@?)?[0-9]/.test(name)) {
+            warn('Variable names beginning with a number are deprecated and will be removed in Less 5.x. Rename the variable to start with a valid identifier character.', index, 'DEPRECATED', 'numeric-variable-name');
+        }
+    }
+
+    /**
+     * A lone '-' is not a CSS identifier. Less historically accepts it as a
+     * variable name; retain that in Less 4 only and warn on definitions,
+     * ordinary references, and interpolation references.
+     *
+     * @param {string} name - either @-/@@-, or the name inside @{...}
+     * @param {number} index - source position of the variable token
+     */
+    function warnDashOnlyVariableName(name, index) {
+        const bareName = name.replace(/^@@?/, '');
+        if (bareName === '-') {
+            warn('The dash-only variable names @- and @{-} are deprecated and will be removed in Less 5.x. Rename the variable to use a valid identifier.', index, 'DEPRECATED', 'dash-only-variable-name');
+        }
+    }
+
+    /**
+     * A lone '-' is not a CSS identifier. Less historically accepts it as a mixin
+     * name after '.' or '#'; retain that in Less 4 only.
+     *
+     * @param {string} name
+     * @param {number} index
+     */
+    function warnDashOnlyMixinName(name, index) {
+        if (name === '.-' || name === '#-') {
+            warn('The dash-only mixin names .-() and #-() are deprecated and will be removed in Less 5.x. Rename the mixin to use a valid CSS identifier.', index, 'DEPRECATED', 'dash-only-mixin-name');
+        }
+    }
+
+    /**
+     * CSS @charset is a source-header declaration, not a general dynamic at-rule.
+     * Less 4 keeps its historical interpolation behavior for compatibility, but
+     * makes each dynamic spelling visible before Less 5 rejects it.
+     *
+     * @param {import('../tree/node.js').default} value
+     * @param {number} index - source position of the @charset token
+     */
+    function warnDynamicCharset(value, index) {
+        if (value instanceof tree.Variable ||
+            (value instanceof tree.Quoted &&
+                (value.containsVariables() || value.value.match(value.propRegex)))) {
+            warn('Dynamic @charset interpolation is deprecated and will be removed in Less 5.x. Use a static quoted encoding declaration instead.', index, 'DEPRECATED', 'dynamic-charset');
+        }
+    }
+
     function expect(arg, msg) {
         // some older browsers return typeof 'function' for RegExp
         const result = (arg instanceof Function) ? arg.call(parsers) : parserInput.$re(arg);
@@ -539,7 +617,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
 
                     function condition() {
-                        return [expect(parsers.condition, 'expected condition')];
+                        return [expect(() => parsers.condition(false, true), 'expected condition')];
                     }
                 },
 
@@ -664,6 +742,8 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
 
                     parserInput.save();
                     if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^@@?[\w-]+/))) {
+                        warnNumericVariableName(name, index);
+                        warnDashOnlyVariableName(name, index);
                         ch = parserInput.currentChar();
                         if ((ch === '(' && !parserInput.prevChar().match(/^\s/))
                             || (ch === '[' && !parserInput.prevChar().match(/^\s/))) {
@@ -686,6 +766,8 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     const index = parserInput.i;
 
                     if (parserInput.currentChar() === '@' && (curly = parserInput.$re(/^@\{([\w-]+)\}/))) {
+                        warnNumericVariableName(curly[1], index);
+                        warnDashOnlyVariableName(curly[1], index);
                         return new(tree.Variable)(`@${curly[1]}`, index + currentIndex, fileInfo);
                     }
                 },
@@ -808,7 +890,11 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
             variable: function () {
                 let name;
 
-                if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*:/))) { return name[1]; }
+                if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\s*:/))) {
+                    warnNumericVariableName(name[1], parserInput.i - name[0].length);
+                    warnDashOnlyVariableName(name[1], parserInput.i - name[0].length);
+                    return name[1];
+                }
             },
 
             //
@@ -838,6 +924,8 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
 
                     if (!inValue) {
+                        warnNumericVariableName(name[1], i);
+                        warnDashOnlyVariableName(name[1], i);
                         name = name[1];
                     }
 
@@ -994,6 +1082,9 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         if (inValue || parsers.end()) {
                             parserInput.forget();
                             const mixin = new(tree.mixin.Call)(elements, args, index + currentIndex, fileInfo, !lookups && important);
+                            for (const element of elements) {
+                                warnDashOnlyMixinName(element.value, element._index - currentIndex);
+                            }
                             if (lookups) {
                                 return new tree.NamespaceValue(mixin, lookups);
                             }
@@ -1190,6 +1281,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     let ruleset;
                     let cond;
                     let variadic = false;
+                    const index = parserInput.i;
                     if ((parserInput.currentChar() !== '.' && parserInput.currentChar() !== '#') ||
                         parserInput.peek(/^[^{]*\}/)) {
                         return;
@@ -1225,6 +1317,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
 
                         if (ruleset) {
                             parserInput.forget();
+                            warnDashOnlyMixinName(name, index);
                             return new(tree.mixin.Definition)(name, params, ruleset, cond, variadic);
                         } else {
                             parserInput.restore();
@@ -1636,7 +1729,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             if (parserInput.$char(';')) {
                                 value = new Anonymous('');
                             } else {
-                                value = this.permissiveValue(/[;}]/, true);
+                                value = this.permissiveValue(/[;}]/);
                             }
                         }
                         // Try to store values as anonymous
@@ -1695,8 +1788,12 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
              * math is allowed.
              * 
              * @param {RexExp} untilTokens - Characters to stop parsing at
+             * @param {boolean} [deprecateVariables] - when set, this is an at-rule
+             *   prelude (non-value position); accept `@{var}` interpolation and warn
+             *   on a bare `@var` reference (which resolves today but is deprecated).
              */
-            permissiveValue: function (untilTokens) {
+            permissiveValue: function (untilTokens, deprecateVariables) {
+                const entities = this.entities;
                 let i;
                 let e;
                 let done;
@@ -1723,7 +1820,20 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         value.push(e);
                         continue;
                     }
-                    e = this.entity();
+                    if (deprecateVariables) {
+                        // In an at-rule prelude, `@{var}` interpolation is the supported
+                        // form; consume it here so its `{` is not mistaken for a block.
+                        e = entities.variableCurly();
+                        if (!e) {
+                            const varIndex = parserInput.i;
+                            e = this.entity();
+                            if (e && e.type === 'Variable') {
+                                warnBareAtRuleVariable(varIndex);
+                            }
+                        }
+                    } else {
+                        e = this.entity();
+                    }
                     if (e) {
                         value.push(e);
                     }
@@ -1750,7 +1860,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 }
                 parserInput.save();
 
-                value = parserInput.$parseUntil(tok);
+                value = parserInput.$parseUntil(tok, deprecateVariables);
 
                 if (value) {
                     if (typeof value === 'string') {
@@ -1760,6 +1870,14 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         parserInput.forget();
                         return new tree.Anonymous('', index);
                     }
+                    // At-rule prelude: `$parseUntil` (deprecateVariables) records the
+                    // first bare `@var` it saw outside any `(...)` in its single pass —
+                    // a structural reference (`[...]`/`{...}` don't shield it, only a
+                    // declaration-value `(...)` does). Warn once here rather than
+                    // re-scanning the text.
+                    if (deprecateVariables && value.bareVarIndex !== null && value.bareVarIndex !== undefined) {
+                        warnBareAtRuleVariable(value.bareVarIndex);
+                    }
                     /** @type {string} */
                     let item;
                     for (i = 0; i < value.length; i++) {
@@ -1776,11 +1894,14 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             const quote = new tree.Quoted('\'', item, true, index, fileInfo);
                             const variableRegex = /@([\w-]+)/g;
                             const propRegex = /\$([\w-]+)/g;
-                            if (variableRegex.test(item)) {
-                                warn('@[ident] in unknown values will not be evaluated as variables in the future. Use @{[ident]}', index, 'DEPRECATED', 'variable-in-unknown-value');
+                            // At-rule preludes are handled once above via
+                            // `value.bareVarIndex`; the `variable-in-unknown-value`
+                            // notice is for unknown declaration values only.
+                            if (!deprecateVariables && variableRegex.test(item)) {
+                                warn('@variable in unknown values will not be evaluated as variables in the future. Use @{variable}', index, 'DEPRECATED', 'variable-in-unknown-value');
                             }
                             if (propRegex.test(item)) {
-                                warn('$[ident] in unknown values will not be evaluated as property references in the future. Use ${[ident]}', index, 'DEPRECATED', 'property-in-unknown-value');
+                                warn('$property in unknown values will not be evaluated as property references in the future. Use ${property}', index, 'DEPRECATED', 'property-in-unknown-value');
                             }
                             quote.variableRegex = /@([\w-]+)|@{([\w-]+)}/g;
                             quote.propRegex = /\$([\w-]+)|\${([\w-]+)}/g;
@@ -1889,7 +2010,17 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                     parserInput.restore();
 
-                    e = entities.declarationCall.bind(this)() || cssKeyword() || entities.keyword() || entities.variable() || entities.mixinLookup()
+                    e = entities.declarationCall.bind(this)() || cssKeyword() || entities.keyword() || entities.variableCurly();
+                    if (!e) {
+                        const varIndex = parserInput.i;
+                        const bareVariable = entities.variable();
+                        if (bareVariable) {
+                            warnBareAtRuleVariable(varIndex);
+                            e = bareVariable;
+                        } else {
+                            e = entities.mixinLookup();
+                        }
+                    }
                     if (e) {
                         nodes.push(e);
                         if (e.type === 'Variable' ||
@@ -1900,7 +2031,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                         let closed = false;
                         p = this.property();
                         parserInput.save();
-                        if (!p && syntaxOptions.queryInParens && parserInput.$re(/^[0-9a-z-]*\s*([<>]=|<=|>=|[<>]|=)/)) {
+                        if (!p && syntaxOptions.queryInParens && parserInput.$re(/^(?:[^()]|\([^()]*\))*\s*([<>]=|<=|>=|[<>]|=)/)) {
                             parserInput.restore();
                             p = this.condition();
 
@@ -1980,7 +2111,17 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             features[features.length - 1].noSpacing = false;
                         }
                     } else {
-                        e = entities.variable() || entities.mixinLookup();
+                        e = entities.variableCurly();
+                        if (!e) {
+                            const varIndex = parserInput.i;
+                            const bareVariable = entities.variable();
+                            if (bareVariable) {
+                                warnBareAtRuleVariable(varIndex);
+                                e = bareVariable;
+                            } else {
+                                e = entities.mixinLookup();
+                            }
+                        }
                         if (e) {
                             features.push(e);
                             if (!parserInput.$char(',')) { break; }
@@ -2094,8 +2235,24 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     return null;
                 }
             },
+            /**
+             * An entity in a non-value at-rule position (an at-rule identifier,
+             * name, or keyword-list item — e.g. the name in `@keyframes @foo`).
+             * `@{foo}` interpolation is the supported form; a bare `@foo` still
+             * resolves but is deprecated.
+             */
+            atRuleEntity: function () {
+                const curly = this.entities.variableCurly();
+                if (curly) { return curly; }
+                const index = parserInput.i;
+                const e = this.entity();
+                if (e && e.type === 'Variable') {
+                    warnBareAtRuleVariable(index);
+                }
+                return e;
+            },
             atruleUnknown: function (value, name, hasBlock) {
-                value = this.permissiveValue(/^[{;]/);
+                value = this.permissiveValue(/^[{;]/, true);
                 hasBlock = (parserInput.currentChar() === '{');
                 if (!value) {
                     if (!hasBlock && parserInput.currentChar() !== ';') {
@@ -2111,16 +2268,16 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 rules = this.blockRuleset();
                 parserInput.save();
                 if (!rules && !isRooted) {
-                    value = this.entity();
+                    value = this.atRuleEntity();
                     rules = this.blockRuleset();
                 }
                 if (!rules && !isRooted) {
                     parserInput.restore();
                     var e = [];
-                    value = this.entity();
+                    value = this.atRuleEntity();
                     while (parserInput.$char(',')) {
                         e.push(value);
-                        value = this.entity();
+                        value = this.atRuleEntity();
                     }
                     if (value && e.length > 0) {
                         e.push(value);
@@ -2205,12 +2362,28 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 parserInput.commentStore.length = 0;
 
                 if (hasIdentifier) {
-                    value = this.entity();
+                    value = this.atRuleEntity();
                     if (!value) {
                         error(`expected ${name} identifier`);
                     }
+                    if (nonVendorSpecificName === '@charset') {
+                        warnDynamicCharset(value, index);
+                    }
                 } else if (hasExpression) {
+                    // `@namespace` may carry an interpolated `@{ns}` prefix (or a
+                    // deprecated bare `@ns`). Parse that prefix directly so `@{ns}`
+                    // is accepted here without treating value positions as
+                    // interpolation contexts, then read the namespace URL.
+                    let prefix = this.entities.variableCurly();
+                    if (!prefix && parserInput.peek(/^@@?[\w-]/)) {
+                        const prefixIndex = parserInput.i;
+                        prefix = this.entities.variable();
+                        if (prefix) { warnBareAtRuleVariable(prefixIndex); }
+                    }
                     value = this.expression();
+                    if (prefix) {
+                        value = value ? new(tree.Expression)([prefix, ...value.value]) : prefix;
+                    }
                     if (!value) {
                         error(`expected ${name} expression`);
                     }
@@ -2400,7 +2573,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     return condition || a;
                 }
             },
-            condition: function (needsParens) {
+            condition: function (needsParens, allowConditionOperands) {
                 let result;
                 let logical;
                 let next;
@@ -2408,13 +2581,13 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     return parserInput.$str('or');
                 }
 
-                result = this.conditionAnd(needsParens);
+                result = this.conditionAnd(needsParens, allowConditionOperands);
                 if (!result) {
                     return ;
                 }
                 logical = or();
                 if (logical) {
-                    next = this.condition(needsParens);
+                    next = this.condition(needsParens, allowConditionOperands);
                     if (next) {
                         result = new(tree.Condition)(logical, result, next);
                     } else {
@@ -2423,13 +2596,13 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 }
                 return result;
             },
-            conditionAnd: function (needsParens) {
+            conditionAnd: function (needsParens, allowConditionOperands) {
                 let result;
                 let logical;
                 let next;
                 const self = this;
                 function insideCondition() {
-                    const cond = self.negatedCondition(needsParens) || self.parenthesisCondition(needsParens);
+                    const cond = self.negatedCondition(needsParens, allowConditionOperands) || self.parenthesisCondition(needsParens, allowConditionOperands);
                     if (!cond && !needsParens) {
                         return self.atomicCondition(needsParens);
                     }
@@ -2443,9 +2616,12 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 if (!result) {
                     return ;
                 }
+                if (allowConditionOperands) {
+                    result = this.atomicCondition(needsParens, result, allowConditionOperands) || result;
+                }
                 logical = and();
                 if (logical) {
-                    next = this.conditionAnd(needsParens);
+                    next = this.conditionAnd(needsParens, allowConditionOperands);
                     if (next) {
                         result = new(tree.Condition)(logical, result, next);
                     } else {
@@ -2454,9 +2630,9 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 }
                 return result;
             },
-            negatedCondition: function (needsParens) {
+            negatedCondition: function (needsParens, allowConditionOperands) {
                 if (parserInput.$str('not')) {
-                    const result = this.parenthesisCondition(needsParens);
+                    const result = this.parenthesisCondition(needsParens, allowConditionOperands);
                     if (result) {
                         result.negate = !result.negate;
                         return result;
@@ -2473,11 +2649,11 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                 }
             },
-            parenthesisCondition: function (needsParens) {
+            parenthesisCondition: function (needsParens, allowConditionOperands) {
                 function tryConditionFollowedByParenthesis(me) {
                     let body;
                     parserInput.save();
-                    body = me.condition(needsParens);
+                    body = me.condition(needsParens, allowConditionOperands);
                     if (!body) {
                         parserInput.restore();
                         return ;
@@ -2514,7 +2690,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 parserInput.forget();
                 return body;
             },
-            atomicCondition: function (needsParens, preparsedCond) {
+            atomicCondition: function (needsParens, preparsedCond, allowConditionOperands) {
                 const entities = this.entities;
                 const index = parserInput.i;
                 let a;
@@ -2523,7 +2699,7 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                 let op;
 
                 const cond = (function() {
-                    return this.addition() || entities.keyword() || entities.quoted() || entities.mixinLookup();
+                    return (allowConditionOperands && this.parenthesisCondition(needsParens)) || this.addition() || entities.keyword() || entities.quoted() || entities.mixinLookup();
                 }).bind(this)
 
                 if (preparsedCond) {
@@ -2684,6 +2860,11 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                     }
                     for (k = 0; k < name.length; k++) {
                         s = name[k];
+                        if (s.charAt(0) === '@') {
+                            const variableName = s.slice(2, -1);
+                            warnNumericVariableName(variableName, index[k]);
+                            warnDashOnlyVariableName(variableName, index[k]);
+                        }
                         name[k] = (s.charAt(0) !== '@' && s.charAt(0) !== '$') ?
                             new(tree.Keyword)(s) :
                             (s.charAt(0) === '@' ?

package/lib/less/tree/mixin-definition.js

@@ -267,35 +267,47 @@ class Definition extends Ruleset {
      */
     matchArgs(args, context) {
         const allArgsCnt = (args && args.length) || 0;
-        let len;
-        const optionalParameters = this.optionalParameters;
-        const requiredArgsCnt = !args ? 0 : args.reduce(function (/** @type {number} */ count, /** @type {MixinArg} */ p) {
-            if (optionalParameters.indexOf(p.name) < 0) {
-                return count + 1;
-            } else {
-                return count;
+        const evaldArguments = new Array(this.params.length);
+        const positionalArgs = [];
+        let positionalIndex = 0;
+
+        for (let i = 0; i < allArgsCnt; i++) {
+            const arg = /** @type {MixinArg[]} */ (args)[i];
+            if (!arg.name) {
+                positionalArgs.push(arg);
+                continue;
             }
-        }, 0);
 
-        if (!this.variadic) {
-            if (requiredArgsCnt < this.required) {
+            const paramIndex = this.params.findIndex((param, index) => param.name === arg.name && !evaldArguments[index]);
+            if (paramIndex < 0) {
                 return false;
             }
-            if (allArgsCnt > this.params.length) {
-                return false;
+            evaldArguments[paramIndex] = arg;
+        }
+
+        for (let i = 0; i < this.params.length; i++) {
+            if (evaldArguments[i]) {
+                continue;
+            }
+            if (this.params[i].variadic) {
+                positionalIndex = positionalArgs.length;
+                continue;
             }
-        } else {
-            if (requiredArgsCnt < (this.required - 1)) {
+            if (positionalIndex < positionalArgs.length) {
+                evaldArguments[i] = positionalArgs[positionalIndex++];
+            } else if (!this.params[i].name || !this.params[i].value) {
                 return false;
             }
         }
 
-        // check patterns
-        len = Math.min(requiredArgsCnt, this.arity);
+        if (positionalIndex < positionalArgs.length) {
+            return false;
+        }
 
-        for (let i = 0; i < len; i++) {
+        // check patterns
+        for (let i = 0; i < this.arity; i++) {
             if (!this.params[i].name && !this.params[i].variadic) {
-                if (/** @type {MixinArg[]} */ (args)[i].value.eval(context).toCSS(/** @type {EvalContext} */ ({})) != /** @type {Node} */ (this.params[i].value).eval(context).toCSS(/** @type {EvalContext} */ ({}))) {
+                if (evaldArguments[i].value.eval(context).toCSS(/** @type {EvalContext} */ ({})) != /** @type {Node} */ (this.params[i].value).eval(context).toCSS(/** @type {EvalContext} */ ({}))) {
                     return false;
                 }
             }

package/lib/less/tree/nested-at-rule.js

@@ -145,16 +145,16 @@ const NestableAtRulePrototype = {
         self.features = new Value(self.permute(/** @type {Node[][]} */ (/** @type {unknown} */ (path))).map(
             /** @param {Node | Node[]} path */
             path => {
-            path = /** @type {Node[]} */ (path).map(
+                path = /** @type {Node[]} */ (path).map(
                 /** @param {Node & { toCSS?: Function }} fragment */
-                fragment => fragment.toCSS ? fragment : new Anonymous(/** @type {string} */ (/** @type {unknown} */ (fragment))));
+                    fragment => fragment.toCSS ? fragment : new Anonymous(/** @type {string} */ (/** @type {unknown} */ (fragment))));
 
-            for (i = /** @type {Node[]} */ (path).length - 1; i > 0; i--) {
+                for (i = /** @type {Node[]} */ (path).length - 1; i > 0; i--) {
                 /** @type {Node[]} */ (path).splice(i, 0, new Anonymous('and'));
-            }
+                }
 
-            return new Expression(/** @type {Node[]} */ (path));
-        }));
+                return new Expression(/** @type {Node[]} */ (path));
+            }));
         self.setParent(self.features, self);
 
         // Fake a tree-node that doesn't output anything.