@vue/compiler-core 3.2.2 → 3.2.6

package/dist/compiler-core.cjs.js

@@ -4,8 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var shared = require('@vue/shared');
 var sourceMap = require('source-map');
-var parser = require('@babel/parser');
+var types = require('@babel/types');
 var estreeWalker = require('estree-walker');
+var parser = require('@babel/parser');
 
 function defaultOnError(error) {
     throw error;
@@ -651,7 +652,10 @@ function injectProp(node, prop, context) {
     }
 }
 function toValidAssetId(name, type) {
-    return `_${type}_${name.replace(/[^\w]/g, '_')}`;
+    // see issue#4422, we need adding identifier on validAssetId if variable `name` has specific character
+    return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+        return searchValue === '-' ? '_' : name.charCodeAt(replaceValue).toString();
+    })}`;
 }
 // Check if a node contains expressions that reference current context scope ids
 function hasScopeRef(node, ids) {
@@ -1866,16 +1870,19 @@ function getGeneratedPropsConstantType(node, context) {
             if (keyType < returnType) {
                 returnType = keyType;
             }
-            if (value.type !== 4 /* SIMPLE_EXPRESSION */) {
+            let valueType;
+            if (value.type === 4 /* SIMPLE_EXPRESSION */) {
+                valueType = getConstantType(value, context);
+            }
+            else if (value.type === 14 /* JS_CALL_EXPRESSION */) {
                 // some helper calls can be hoisted,
                 // such as the `normalizeProps` generated by the compiler for pre-normalize class,
                 // in this case we need to respect the ConstanType of the helper's argments
-                if (value.type === 14 /* JS_CALL_EXPRESSION */) {
-                    return getConstantTypeOfHelperCall(value, context);
-                }
-                return 0 /* NOT_CONSTANT */;
+                valueType = getConstantTypeOfHelperCall(value, context);
+            }
+            else {
+                valueType = 0 /* NOT_CONSTANT */;
             }
-            const valueType = getConstantType(value, context);
             if (valueType === 0 /* NOT_CONSTANT */) {
                 return valueType;
             }
@@ -2972,6 +2979,177 @@ function genReturnStatement({ returns }, context) {
     }
 }
 
+function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = Object.create(null)) {
+    const rootExp = root.type === 'Program' &&
+        root.body[0].type === 'ExpressionStatement' &&
+        root.body[0].expression;
+    estreeWalker.walk(root, {
+        enter(node, parent) {
+            parent && parentStack.push(parent);
+            if (parent &&
+                parent.type.startsWith('TS') &&
+                parent.type !== 'TSAsExpression' &&
+                parent.type !== 'TSNonNullExpression' &&
+                parent.type !== 'TSTypeAssertion') {
+                return this.skip();
+            }
+            if (node.type === 'Identifier') {
+                const isLocal = !!knownIds[node.name];
+                const isRefed = isReferencedIdentifier(node, parent, parentStack);
+                if (includeAll || (isRefed && !isLocal)) {
+                    onIdentifier(node, parent, parentStack, isRefed, isLocal);
+                }
+            }
+            else if (node.type === 'ObjectProperty' &&
+                parent.type === 'ObjectPattern') {
+                node.inPattern = true;
+            }
+            else if (isFunctionType(node)) {
+                // walk function expressions and add its arguments to known identifiers
+                // so that we don't prefix them
+                walkFunctionParams(node, id => markScopeIdentifier(node, id, knownIds));
+            }
+            else if (node.type === 'BlockStatement') {
+                // #3445 record block-level local variables
+                walkBlockDeclarations(node, id => markScopeIdentifier(node, id, knownIds));
+            }
+        },
+        leave(node, parent) {
+            parent && parentStack.pop();
+            if (node !== rootExp && node.scopeIds) {
+                for (const id of node.scopeIds) {
+                    knownIds[id]--;
+                    if (knownIds[id] === 0) {
+                        delete knownIds[id];
+                    }
+                }
+            }
+        }
+    });
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+    if (!parent) {
+        return true;
+    }
+    // is a special keyword but parsed as identifier
+    if (id.name === 'arguments') {
+        return false;
+    }
+    if (types.isReferenced(id, parent)) {
+        return true;
+    }
+    // babel's isReferenced check returns false for ids being assigned to, so we
+    // need to cover those cases here
+    switch (parent.type) {
+        case 'AssignmentExpression':
+        case 'AssignmentPattern':
+            return true;
+        case 'ObjectPattern':
+        case 'ArrayPattern':
+            return isInDestructureAssignment(parent, parentStack);
+    }
+    return false;
+}
+function isInDestructureAssignment(parent, parentStack) {
+    if (parent &&
+        (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) {
+        let i = parentStack.length;
+        while (i--) {
+            const p = parentStack[i];
+            if (p.type === 'AssignmentExpression') {
+                return true;
+            }
+            else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
+                break;
+            }
+        }
+    }
+    return false;
+}
+function walkFunctionParams(node, onIdent) {
+    for (const p of node.params) {
+        for (const id of extractIdentifiers(p)) {
+            onIdent(id);
+        }
+    }
+}
+function walkBlockDeclarations(block, onIdent) {
+    for (const stmt of block.body) {
+        if (stmt.type === 'VariableDeclaration') {
+            if (stmt.declare)
+                continue;
+            for (const decl of stmt.declarations) {
+                for (const id of extractIdentifiers(decl.id)) {
+                    onIdent(id);
+                }
+            }
+        }
+        else if (stmt.type === 'FunctionDeclaration' ||
+            stmt.type === 'ClassDeclaration') {
+            if (stmt.declare || !stmt.id)
+                continue;
+            onIdent(stmt.id);
+        }
+    }
+}
+function extractIdentifiers(param, nodes = []) {
+    switch (param.type) {
+        case 'Identifier':
+            nodes.push(param);
+            break;
+        case 'MemberExpression':
+            let object = param;
+            while (object.type === 'MemberExpression') {
+                object = object.object;
+            }
+            nodes.push(object);
+            break;
+        case 'ObjectPattern':
+            for (const prop of param.properties) {
+                if (prop.type === 'RestElement') {
+                    extractIdentifiers(prop.argument, nodes);
+                }
+                else {
+                    extractIdentifiers(prop.value, nodes);
+                }
+            }
+            break;
+        case 'ArrayPattern':
+            param.elements.forEach(element => {
+                if (element)
+                    extractIdentifiers(element, nodes);
+            });
+            break;
+        case 'RestElement':
+            extractIdentifiers(param.argument, nodes);
+            break;
+        case 'AssignmentPattern':
+            extractIdentifiers(param.left, nodes);
+            break;
+    }
+    return nodes;
+}
+function markScopeIdentifier(node, child, knownIds) {
+    const { name } = child;
+    if (node.scopeIds && node.scopeIds.has(name)) {
+        return;
+    }
+    if (name in knownIds) {
+        knownIds[name]++;
+    }
+    else {
+        knownIds[name] = 1;
+    }
+    (node.scopeIds || (node.scopeIds = new Set())).add(name);
+}
+const isFunctionType = (node) => {
+    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+const isStaticProperty = (node) => node &&
+    (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
+    !node.computed;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+
 const isLiteralWhitelisted = /*#__PURE__*/ shared.makeMap('true,false,null,this');
 const transformExpression = (node, context) => {
     if (node.type === 5 /* INTERPOLATION */) {
@@ -3137,81 +3315,36 @@ asRawStatements = false) {
         return node;
     }
     const ids = [];
-    const knownIds = Object.create(context.identifiers);
-    const isDuplicate = (node) => ids.some(id => id.start === node.start);
     const parentStack = [];
-    estreeWalker.walk(ast, {
-        enter(node, parent) {
-            parent && parentStack.push(parent);
-            if (node.type === 'Identifier') {
-                if (!isDuplicate(node)) {
-                    // v2 wrapped filter call
-                    if (node.name.startsWith('_filter_')) {
-                        return;
-                    }
-                    const needPrefix = shouldPrefix(node, parent, parentStack);
-                    if (!knownIds[node.name] && needPrefix) {
-                        if (isStaticProperty(parent) && parent.shorthand) {
-                            // property shorthand like { foo }, we need to add the key since
-                            // we rewrite the value
-                            node.prefix = `${node.name}: `;
-                        }
-                        node.name = rewriteIdentifier(node.name, parent, node);
-                        ids.push(node);
-                    }
-                    else if (!isStaticPropertyKey(node, parent)) {
-                        // The identifier is considered constant unless it's pointing to a
-                        // scope variable (a v-for alias, or a v-slot prop)
-                        if (!(needPrefix && knownIds[node.name]) && !bailConstant) {
-                            node.isConstant = true;
-                        }
-                        // also generate sub-expressions for other identifiers for better
-                        // source map support. (except for property keys which are static)
-                        ids.push(node);
-                    }
-                }
-            }
-            else if (isFunction(node)) {
-                // walk function expressions and add its arguments to known identifiers
-                // so that we don't prefix them
-                node.params.forEach(p => estreeWalker.walk(p, {
-                    enter(child, parent) {
-                        if (child.type === 'Identifier' &&
-                            // do not record as scope variable if is a destructured key
-                            !isStaticPropertyKey(child, parent) &&
-                            // do not record if this is a default value
-                            // assignment of a destructured variable
-                            !(parent &&
-                                parent.type === 'AssignmentPattern' &&
-                                parent.right === child)) {
-                            const { name } = child;
-                            if (node.scopeIds && node.scopeIds.has(name)) {
-                                return;
-                            }
-                            if (name in knownIds) {
-                                knownIds[name]++;
-                            }
-                            else {
-                                knownIds[name] = 1;
-                            }
-                            (node.scopeIds || (node.scopeIds = new Set())).add(name);
-                        }
-                    }
-                }));
+    const knownIds = Object.create(context.identifiers);
+    walkIdentifiers(ast, (node, parent, _, isReferenced, isLocal) => {
+        if (isStaticPropertyKey(node, parent)) {
+            return;
+        }
+        // v2 wrapped filter call
+        if (node.name.startsWith('_filter_')) {
+            return;
+        }
+        const needPrefix = isReferenced && canPrefix(node);
+        if (needPrefix && !isLocal) {
+            if (isStaticProperty(parent) && parent.shorthand) {
+                node.prefix = `${node.name}: `;
             }
-        },
-        leave(node, parent) {
-            parent && parentStack.pop();
-            if (node !== ast.body[0].expression && node.scopeIds) {
-                node.scopeIds.forEach((id) => {
-                    knownIds[id]--;
-                    if (knownIds[id] === 0) {
-                        delete knownIds[id];
-                    }
-                });
+            node.name = rewriteIdentifier(node.name, parent, node);
+            ids.push(node);
+        }
+        else {
+            // The identifier is considered constant unless it's pointing to a
+            // local scope variable (a v-for alias, or a v-slot prop)
+            if (!(needPrefix && isLocal) && !bailConstant) {
+                node.isConstant = true;
             }
+            // also generate sub-expressions for other identifiers for better
+            // source map support. (except for property keys which are static)
+            ids.push(node);
         }
-    });
+    }, true, // invoke on ALL identifiers
+    parentStack, knownIds);
     // We break up the compound expression into an array of strings and sub
     // expressions (for identifiers that have been prefixed). In codegen, if
     // an ExpressionNode has the `.children` property, it will be used instead of
@@ -3250,51 +3383,7 @@ asRawStatements = false) {
     ret.identifiers = Object.keys(knownIds);
     return ret;
 }
-const isFunction = (node) => {
-    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
-};
-const isStaticProperty = (node) => node &&
-    (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
-    !node.computed;
-const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
-function shouldPrefix(id, parent, parentStack) {
-    // declaration id
-    if ((parent.type === 'VariableDeclarator' ||
-        parent.type === 'ClassDeclaration') &&
-        parent.id === id) {
-        return false;
-    }
-    if (isFunction(parent)) {
-        // function decalration/expression id
-        if (parent.id === id) {
-            return false;
-        }
-        // params list
-        if (parent.params.includes(id)) {
-            return false;
-        }
-    }
-    // property key
-    // this also covers object destructure pattern
-    if (isStaticPropertyKey(id, parent)) {
-        return false;
-    }
-    // non-assignment array destructure pattern
-    if (parent.type === 'ArrayPattern' &&
-        !isInDestructureAssignment(parent, parentStack)) {
-        return false;
-    }
-    // member expression property
-    if ((parent.type === 'MemberExpression' ||
-        parent.type === 'OptionalMemberExpression') &&
-        parent.property === id &&
-        !parent.computed) {
-        return false;
-    }
-    // is a special keyword but parsed as identifier
-    if (id.name === 'arguments') {
-        return false;
-    }
+function canPrefix(id) {
     // skip whitelisted globals
     if (shared.isGloballyWhitelisted(id.name)) {
         return false;
@@ -3305,22 +3394,6 @@ function shouldPrefix(id, parent, parentStack) {
     }
     return true;
 }
-function isInDestructureAssignment(parent, parentStack) {
-    if (parent &&
-        (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) {
-        let i = parentStack.length;
-        while (i--) {
-            const p = parentStack[i];
-            if (p.type === 'AssignmentExpression') {
-                return true;
-            }
-            else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
-                break;
-            }
-        }
-    }
-    return false;
-}
 function stringifyExpression(exp) {
     if (shared.isString(exp)) {
         return exp;
@@ -4567,7 +4640,10 @@ function buildProps(node, context, props = node.props, ssr = false) {
                         !isStaticExp(styleProp.value) &&
                         // the static style is compiled into an object,
                         // so use `hasStyleBinding` to ensure that it is a dynamic style binding
-                        hasStyleBinding) {
+                        (hasStyleBinding ||
+                            // v-bind:style and style both exist,
+                            // v-bind:style with static literal object
+                            styleProp.value.type === 17 /* JS_ARRAY_EXPRESSION */)) {
                         styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]);
                     }
                 }
@@ -5468,6 +5544,7 @@ exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
 exports.createTemplateLiteral = createTemplateLiteral;
 exports.createTransformContext = createTransformContext;
 exports.createVNodeCall = createVNodeCall;
+exports.extractIdentifiers = extractIdentifiers;
 exports.findDir = findDir;
 exports.findProp = findProp;
 exports.generate = generate;
@@ -5483,10 +5560,15 @@ exports.injectProp = injectProp;
 exports.isBindKey = isBindKey;
 exports.isBuiltInType = isBuiltInType;
 exports.isCoreComponent = isCoreComponent;
+exports.isFunctionType = isFunctionType;
+exports.isInDestructureAssignment = isInDestructureAssignment;
 exports.isMemberExpression = isMemberExpression;
+exports.isReferencedIdentifier = isReferencedIdentifier;
 exports.isSimpleIdentifier = isSimpleIdentifier;
 exports.isSlotOutlet = isSlotOutlet;
 exports.isStaticExp = isStaticExp;
+exports.isStaticProperty = isStaticProperty;
+exports.isStaticPropertyKey = isStaticPropertyKey;
 exports.isTemplateNode = isTemplateNode;
 exports.isText = isText;
 exports.isVSlot = isVSlot;
@@ -5509,4 +5591,7 @@ exports.transformExpression = transformExpression;
 exports.transformModel = transformModel;
 exports.transformOn = transformOn;
 exports.traverseNode = traverseNode;
+exports.walkBlockDeclarations = walkBlockDeclarations;
+exports.walkFunctionParams = walkFunctionParams;
+exports.walkIdentifiers = walkIdentifiers;
 exports.warnDeprecation = warnDeprecation;

package/dist/compiler-core.cjs.prod.js

@@ -4,8 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var shared = require('@vue/shared');
 var sourceMap = require('source-map');
-var parser = require('@babel/parser');
+var types = require('@babel/types');
 var estreeWalker = require('estree-walker');
+var parser = require('@babel/parser');
 
 function defaultOnError(error) {
     throw error;
@@ -650,7 +651,10 @@ function injectProp(node, prop, context) {
     }
 }
 function toValidAssetId(name, type) {
-    return `_${type}_${name.replace(/[^\w]/g, '_')}`;
+    // see issue#4422, we need adding identifier on validAssetId if variable `name` has specific character
+    return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+        return searchValue === '-' ? '_' : name.charCodeAt(replaceValue).toString();
+    })}`;
 }
 // Check if a node contains expressions that reference current context scope ids
 function hasScopeRef(node, ids) {
@@ -1839,16 +1843,19 @@ function getGeneratedPropsConstantType(node, context) {
             if (keyType < returnType) {
                 returnType = keyType;
             }
-            if (value.type !== 4 /* SIMPLE_EXPRESSION */) {
+            let valueType;
+            if (value.type === 4 /* SIMPLE_EXPRESSION */) {
+                valueType = getConstantType(value, context);
+            }
+            else if (value.type === 14 /* JS_CALL_EXPRESSION */) {
                 // some helper calls can be hoisted,
                 // such as the `normalizeProps` generated by the compiler for pre-normalize class,
                 // in this case we need to respect the ConstanType of the helper's argments
-                if (value.type === 14 /* JS_CALL_EXPRESSION */) {
-                    return getConstantTypeOfHelperCall(value, context);
-                }
-                return 0 /* NOT_CONSTANT */;
+                valueType = getConstantTypeOfHelperCall(value, context);
+            }
+            else {
+                valueType = 0 /* NOT_CONSTANT */;
             }
-            const valueType = getConstantType(value, context);
             if (valueType === 0 /* NOT_CONSTANT */) {
                 return valueType;
             }
@@ -2910,6 +2917,177 @@ function genReturnStatement({ returns }, context) {
     }
 }
 
+function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = Object.create(null)) {
+    const rootExp = root.type === 'Program' &&
+        root.body[0].type === 'ExpressionStatement' &&
+        root.body[0].expression;
+    estreeWalker.walk(root, {
+        enter(node, parent) {
+            parent && parentStack.push(parent);
+            if (parent &&
+                parent.type.startsWith('TS') &&
+                parent.type !== 'TSAsExpression' &&
+                parent.type !== 'TSNonNullExpression' &&
+                parent.type !== 'TSTypeAssertion') {
+                return this.skip();
+            }
+            if (node.type === 'Identifier') {
+                const isLocal = !!knownIds[node.name];
+                const isRefed = isReferencedIdentifier(node, parent, parentStack);
+                if (includeAll || (isRefed && !isLocal)) {
+                    onIdentifier(node, parent, parentStack, isRefed, isLocal);
+                }
+            }
+            else if (node.type === 'ObjectProperty' &&
+                parent.type === 'ObjectPattern') {
+                node.inPattern = true;
+            }
+            else if (isFunctionType(node)) {
+                // walk function expressions and add its arguments to known identifiers
+                // so that we don't prefix them
+                walkFunctionParams(node, id => markScopeIdentifier(node, id, knownIds));
+            }
+            else if (node.type === 'BlockStatement') {
+                // #3445 record block-level local variables
+                walkBlockDeclarations(node, id => markScopeIdentifier(node, id, knownIds));
+            }
+        },
+        leave(node, parent) {
+            parent && parentStack.pop();
+            if (node !== rootExp && node.scopeIds) {
+                for (const id of node.scopeIds) {
+                    knownIds[id]--;
+                    if (knownIds[id] === 0) {
+                        delete knownIds[id];
+                    }
+                }
+            }
+        }
+    });
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+    if (!parent) {
+        return true;
+    }
+    // is a special keyword but parsed as identifier
+    if (id.name === 'arguments') {
+        return false;
+    }
+    if (types.isReferenced(id, parent)) {
+        return true;
+    }
+    // babel's isReferenced check returns false for ids being assigned to, so we
+    // need to cover those cases here
+    switch (parent.type) {
+        case 'AssignmentExpression':
+        case 'AssignmentPattern':
+            return true;
+        case 'ObjectPattern':
+        case 'ArrayPattern':
+            return isInDestructureAssignment(parent, parentStack);
+    }
+    return false;
+}
+function isInDestructureAssignment(parent, parentStack) {
+    if (parent &&
+        (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) {
+        let i = parentStack.length;
+        while (i--) {
+            const p = parentStack[i];
+            if (p.type === 'AssignmentExpression') {
+                return true;
+            }
+            else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
+                break;
+            }
+        }
+    }
+    return false;
+}
+function walkFunctionParams(node, onIdent) {
+    for (const p of node.params) {
+        for (const id of extractIdentifiers(p)) {
+            onIdent(id);
+        }
+    }
+}
+function walkBlockDeclarations(block, onIdent) {
+    for (const stmt of block.body) {
+        if (stmt.type === 'VariableDeclaration') {
+            if (stmt.declare)
+                continue;
+            for (const decl of stmt.declarations) {
+                for (const id of extractIdentifiers(decl.id)) {
+                    onIdent(id);
+                }
+            }
+        }
+        else if (stmt.type === 'FunctionDeclaration' ||
+            stmt.type === 'ClassDeclaration') {
+            if (stmt.declare || !stmt.id)
+                continue;
+            onIdent(stmt.id);
+        }
+    }
+}
+function extractIdentifiers(param, nodes = []) {
+    switch (param.type) {
+        case 'Identifier':
+            nodes.push(param);
+            break;
+        case 'MemberExpression':
+            let object = param;
+            while (object.type === 'MemberExpression') {
+                object = object.object;
+            }
+            nodes.push(object);
+            break;
+        case 'ObjectPattern':
+            for (const prop of param.properties) {
+                if (prop.type === 'RestElement') {
+                    extractIdentifiers(prop.argument, nodes);
+                }
+                else {
+                    extractIdentifiers(prop.value, nodes);
+                }
+            }
+            break;
+        case 'ArrayPattern':
+            param.elements.forEach(element => {
+                if (element)
+                    extractIdentifiers(element, nodes);
+            });
+            break;
+        case 'RestElement':
+            extractIdentifiers(param.argument, nodes);
+            break;
+        case 'AssignmentPattern':
+            extractIdentifiers(param.left, nodes);
+            break;
+    }
+    return nodes;
+}
+function markScopeIdentifier(node, child, knownIds) {
+    const { name } = child;
+    if (node.scopeIds && node.scopeIds.has(name)) {
+        return;
+    }
+    if (name in knownIds) {
+        knownIds[name]++;
+    }
+    else {
+        knownIds[name] = 1;
+    }
+    (node.scopeIds || (node.scopeIds = new Set())).add(name);
+}
+const isFunctionType = (node) => {
+    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+const isStaticProperty = (node) => node &&
+    (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
+    !node.computed;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+
 const isLiteralWhitelisted = /*#__PURE__*/ shared.makeMap('true,false,null,this');
 const transformExpression = (node, context) => {
     if (node.type === 5 /* INTERPOLATION */) {
@@ -3075,81 +3253,36 @@ asRawStatements = false) {
         return node;
     }
     const ids = [];
-    const knownIds = Object.create(context.identifiers);
-    const isDuplicate = (node) => ids.some(id => id.start === node.start);
     const parentStack = [];
-    estreeWalker.walk(ast, {
-        enter(node, parent) {
-            parent && parentStack.push(parent);
-            if (node.type === 'Identifier') {
-                if (!isDuplicate(node)) {
-                    // v2 wrapped filter call
-                    if (node.name.startsWith('_filter_')) {
-                        return;
-                    }
-                    const needPrefix = shouldPrefix(node, parent, parentStack);
-                    if (!knownIds[node.name] && needPrefix) {
-                        if (isStaticProperty(parent) && parent.shorthand) {
-                            // property shorthand like { foo }, we need to add the key since
-                            // we rewrite the value
-                            node.prefix = `${node.name}: `;
-                        }
-                        node.name = rewriteIdentifier(node.name, parent, node);
-                        ids.push(node);
-                    }
-                    else if (!isStaticPropertyKey(node, parent)) {
-                        // The identifier is considered constant unless it's pointing to a
-                        // scope variable (a v-for alias, or a v-slot prop)
-                        if (!(needPrefix && knownIds[node.name]) && !bailConstant) {
-                            node.isConstant = true;
-                        }
-                        // also generate sub-expressions for other identifiers for better
-                        // source map support. (except for property keys which are static)
-                        ids.push(node);
-                    }
-                }
-            }
-            else if (isFunction(node)) {
-                // walk function expressions and add its arguments to known identifiers
-                // so that we don't prefix them
-                node.params.forEach(p => estreeWalker.walk(p, {
-                    enter(child, parent) {
-                        if (child.type === 'Identifier' &&
-                            // do not record as scope variable if is a destructured key
-                            !isStaticPropertyKey(child, parent) &&
-                            // do not record if this is a default value
-                            // assignment of a destructured variable
-                            !(parent &&
-                                parent.type === 'AssignmentPattern' &&
-                                parent.right === child)) {
-                            const { name } = child;
-                            if (node.scopeIds && node.scopeIds.has(name)) {
-                                return;
-                            }
-                            if (name in knownIds) {
-                                knownIds[name]++;
-                            }
-                            else {
-                                knownIds[name] = 1;
-                            }
-                            (node.scopeIds || (node.scopeIds = new Set())).add(name);
-                        }
-                    }
-                }));
+    const knownIds = Object.create(context.identifiers);
+    walkIdentifiers(ast, (node, parent, _, isReferenced, isLocal) => {
+        if (isStaticPropertyKey(node, parent)) {
+            return;
+        }
+        // v2 wrapped filter call
+        if (node.name.startsWith('_filter_')) {
+            return;
+        }
+        const needPrefix = isReferenced && canPrefix(node);
+        if (needPrefix && !isLocal) {
+            if (isStaticProperty(parent) && parent.shorthand) {
+                node.prefix = `${node.name}: `;
             }
-        },
-        leave(node, parent) {
-            parent && parentStack.pop();
-            if (node !== ast.body[0].expression && node.scopeIds) {
-                node.scopeIds.forEach((id) => {
-                    knownIds[id]--;
-                    if (knownIds[id] === 0) {
-                        delete knownIds[id];
-                    }
-                });
+            node.name = rewriteIdentifier(node.name, parent, node);
+            ids.push(node);
+        }
+        else {
+            // The identifier is considered constant unless it's pointing to a
+            // local scope variable (a v-for alias, or a v-slot prop)
+            if (!(needPrefix && isLocal) && !bailConstant) {
+                node.isConstant = true;
             }
+            // also generate sub-expressions for other identifiers for better
+            // source map support. (except for property keys which are static)
+            ids.push(node);
         }
-    });
+    }, true, // invoke on ALL identifiers
+    parentStack, knownIds);
     // We break up the compound expression into an array of strings and sub
     // expressions (for identifiers that have been prefixed). In codegen, if
     // an ExpressionNode has the `.children` property, it will be used instead of
@@ -3188,51 +3321,7 @@ asRawStatements = false) {
     ret.identifiers = Object.keys(knownIds);
     return ret;
 }
-const isFunction = (node) => {
-    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
-};
-const isStaticProperty = (node) => node &&
-    (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
-    !node.computed;
-const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
-function shouldPrefix(id, parent, parentStack) {
-    // declaration id
-    if ((parent.type === 'VariableDeclarator' ||
-        parent.type === 'ClassDeclaration') &&
-        parent.id === id) {
-        return false;
-    }
-    if (isFunction(parent)) {
-        // function decalration/expression id
-        if (parent.id === id) {
-            return false;
-        }
-        // params list
-        if (parent.params.includes(id)) {
-            return false;
-        }
-    }
-    // property key
-    // this also covers object destructure pattern
-    if (isStaticPropertyKey(id, parent)) {
-        return false;
-    }
-    // non-assignment array destructure pattern
-    if (parent.type === 'ArrayPattern' &&
-        !isInDestructureAssignment(parent, parentStack)) {
-        return false;
-    }
-    // member expression property
-    if ((parent.type === 'MemberExpression' ||
-        parent.type === 'OptionalMemberExpression') &&
-        parent.property === id &&
-        !parent.computed) {
-        return false;
-    }
-    // is a special keyword but parsed as identifier
-    if (id.name === 'arguments') {
-        return false;
-    }
+function canPrefix(id) {
     // skip whitelisted globals
     if (shared.isGloballyWhitelisted(id.name)) {
         return false;
@@ -3243,22 +3332,6 @@ function shouldPrefix(id, parent, parentStack) {
     }
     return true;
 }
-function isInDestructureAssignment(parent, parentStack) {
-    if (parent &&
-        (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) {
-        let i = parentStack.length;
-        while (i--) {
-            const p = parentStack[i];
-            if (p.type === 'AssignmentExpression') {
-                return true;
-            }
-            else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
-                break;
-            }
-        }
-    }
-    return false;
-}
 function stringifyExpression(exp) {
     if (shared.isString(exp)) {
         return exp;
@@ -4443,7 +4516,10 @@ function buildProps(node, context, props = node.props, ssr = false) {
                         !isStaticExp(styleProp.value) &&
                         // the static style is compiled into an object,
                         // so use `hasStyleBinding` to ensure that it is a dynamic style binding
-                        hasStyleBinding) {
+                        (hasStyleBinding ||
+                            // v-bind:style and style both exist,
+                            // v-bind:style with static literal object
+                            styleProp.value.type === 17 /* JS_ARRAY_EXPRESSION */)) {
                         styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]);
                     }
                 }
@@ -5340,6 +5416,7 @@ exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
 exports.createTemplateLiteral = createTemplateLiteral;
 exports.createTransformContext = createTransformContext;
 exports.createVNodeCall = createVNodeCall;
+exports.extractIdentifiers = extractIdentifiers;
 exports.findDir = findDir;
 exports.findProp = findProp;
 exports.generate = generate;
@@ -5355,10 +5432,15 @@ exports.injectProp = injectProp;
 exports.isBindKey = isBindKey;
 exports.isBuiltInType = isBuiltInType;
 exports.isCoreComponent = isCoreComponent;
+exports.isFunctionType = isFunctionType;
+exports.isInDestructureAssignment = isInDestructureAssignment;
 exports.isMemberExpression = isMemberExpression;
+exports.isReferencedIdentifier = isReferencedIdentifier;
 exports.isSimpleIdentifier = isSimpleIdentifier;
 exports.isSlotOutlet = isSlotOutlet;
 exports.isStaticExp = isStaticExp;
+exports.isStaticProperty = isStaticProperty;
+exports.isStaticPropertyKey = isStaticPropertyKey;
 exports.isTemplateNode = isTemplateNode;
 exports.isText = isText;
 exports.isVSlot = isVSlot;
@@ -5381,4 +5463,7 @@ exports.transformExpression = transformExpression;
 exports.transformModel = transformModel;
 exports.transformOn = transformOn;
 exports.traverseNode = traverseNode;
+exports.walkBlockDeclarations = walkBlockDeclarations;
+exports.walkFunctionParams = walkFunctionParams;
+exports.walkIdentifiers = walkIdentifiers;
 exports.warnDeprecation = warnDeprecation;

package/dist/compiler-core.d.ts

@@ -1,5 +1,11 @@
+import { BlockStatement as BlockStatement_2 } from '@babel/types';
+import { Function as Function_2 } from '@babel/types';
 import { generateCodeFrame } from '@vue/shared';
+import { Identifier } from '@babel/types';
+import { Node as Node_3 } from '@babel/types';
+import { ObjectProperty } from '@babel/types';
 import { ParserPlugin } from '@babel/parser';
+import { Program } from '@babel/types';
 import { RawSourceMap } from 'source-map';
 import { SourceMapGenerator } from 'source-map';
 
@@ -438,6 +444,8 @@ declare interface ErrorHandlingOptions {
 
 export declare type ExpressionNode = SimpleExpressionNode | CompoundExpressionNode;
 
+export declare function extractIdentifiers(param: Node_3, nodes?: Identifier[]): Identifier[];
+
 export declare function findDir(node: ElementNode, name: string | RegExp, allowEmpty?: boolean): DirectiveNode | undefined;
 
 export declare function findProp(node: ElementNode, name: string, dynamicOnly?: boolean, allowEmpty?: boolean): ElementNode['props'][0] | undefined;
@@ -575,6 +583,10 @@ export declare const isBuiltInType: (tag: string, expected: string) => boolean;
 
 export declare function isCoreComponent(tag: string): symbol | void;
 
+export declare const isFunctionType: (node: Node_3) => node is Function_2;
+
+export declare function isInDestructureAssignment(parent: Node_3, parentStack: Node_3[]): boolean;
+
 /**
  * Simple lexer to check if an expression is a member expression. This is
  * lax and only checks validity at the root level (i.e. does not validate exps
@@ -583,12 +595,18 @@ export declare function isCoreComponent(tag: string): symbol | void;
  */
 export declare const isMemberExpression: (path: string) => boolean;
 
+export declare function isReferencedIdentifier(id: Identifier, parent: Node_3 | null, parentStack: Node_3[]): boolean;
+
 export declare const isSimpleIdentifier: (name: string) => boolean;
 
 export declare function isSlotOutlet(node: RootNode | TemplateChildNode): node is SlotOutletNode;
 
 export declare const isStaticExp: (p: JSChildNode) => p is SimpleExpressionNode;
 
+export declare const isStaticProperty: (node: Node_3) => node is ObjectProperty;
+
+export declare const isStaticPropertyKey: (node: Node_3, parent: Node_3) => boolean;
+
 export declare function isTemplateNode(node: RootNode | TemplateChildNode): node is TemplateNode;
 
 export declare function isText(node: TemplateChildNode): node is TextNode | InterpolationNode;
@@ -1138,6 +1156,12 @@ export declare interface VNodeCall extends Node_2 {
     isComponent: boolean;
 }
 
+export declare function walkBlockDeclarations(block: BlockStatement_2 | Program, onIdent: (node: Identifier) => void): void;
+
+export declare function walkFunctionParams(node: Function_2, onIdent: (id: Identifier) => void): void;
+
+export declare function walkIdentifiers(root: Node_3, onIdentifier: (node: Identifier, parent: Node_3, parentStack: Node_3[], isReference: boolean, isLocal: boolean) => void, includeAll?: boolean, parentStack?: Node_3[], knownIds?: Record<string, number>): void;
+
 export declare function warnDeprecation(key: CompilerDeprecationTypes, context: ParserContext | TransformContext, loc: SourceLocation | null, ...args: any[]): void;
 
 export declare const WITH_CTX: unique symbol;

package/dist/compiler-core.esm-bundler.js

@@ -646,7 +646,10 @@ function injectProp(node, prop, context) {
     }
 }
 function toValidAssetId(name, type) {
-    return `_${type}_${name.replace(/[^\w]/g, '_')}`;
+    // see issue#4422, we need adding identifier on validAssetId if variable `name` has specific character
+    return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+        return searchValue === '-' ? '_' : name.charCodeAt(replaceValue).toString();
+    })}`;
 }
 // Check if a node contains expressions that reference current context scope ids
 function hasScopeRef(node, ids) {
@@ -1865,16 +1868,19 @@ function getGeneratedPropsConstantType(node, context) {
             if (keyType < returnType) {
                 returnType = keyType;
             }
-            if (value.type !== 4 /* SIMPLE_EXPRESSION */) {
+            let valueType;
+            if (value.type === 4 /* SIMPLE_EXPRESSION */) {
+                valueType = getConstantType(value, context);
+            }
+            else if (value.type === 14 /* JS_CALL_EXPRESSION */) {
                 // some helper calls can be hoisted,
                 // such as the `normalizeProps` generated by the compiler for pre-normalize class,
                 // in this case we need to respect the ConstanType of the helper's argments
-                if (value.type === 14 /* JS_CALL_EXPRESSION */) {
-                    return getConstantTypeOfHelperCall(value, context);
-                }
-                return 0 /* NOT_CONSTANT */;
+                valueType = getConstantTypeOfHelperCall(value, context);
+            }
+            else {
+                valueType = 0 /* NOT_CONSTANT */;
             }
-            const valueType = getConstantType(value, context);
             if (valueType === 0 /* NOT_CONSTANT */) {
                 return valueType;
             }
@@ -2742,6 +2748,103 @@ function genCacheExpression(node, context) {
     push(`)`);
 }
 
+function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = Object.create(null)) {
+    {
+        return;
+    }
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+    {
+        return false;
+    }
+}
+function isInDestructureAssignment(parent, parentStack) {
+    if (parent &&
+        (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) {
+        let i = parentStack.length;
+        while (i--) {
+            const p = parentStack[i];
+            if (p.type === 'AssignmentExpression') {
+                return true;
+            }
+            else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
+                break;
+            }
+        }
+    }
+    return false;
+}
+function walkFunctionParams(node, onIdent) {
+    for (const p of node.params) {
+        for (const id of extractIdentifiers(p)) {
+            onIdent(id);
+        }
+    }
+}
+function walkBlockDeclarations(block, onIdent) {
+    for (const stmt of block.body) {
+        if (stmt.type === 'VariableDeclaration') {
+            if (stmt.declare)
+                continue;
+            for (const decl of stmt.declarations) {
+                for (const id of extractIdentifiers(decl.id)) {
+                    onIdent(id);
+                }
+            }
+        }
+        else if (stmt.type === 'FunctionDeclaration' ||
+            stmt.type === 'ClassDeclaration') {
+            if (stmt.declare || !stmt.id)
+                continue;
+            onIdent(stmt.id);
+        }
+    }
+}
+function extractIdentifiers(param, nodes = []) {
+    switch (param.type) {
+        case 'Identifier':
+            nodes.push(param);
+            break;
+        case 'MemberExpression':
+            let object = param;
+            while (object.type === 'MemberExpression') {
+                object = object.object;
+            }
+            nodes.push(object);
+            break;
+        case 'ObjectPattern':
+            for (const prop of param.properties) {
+                if (prop.type === 'RestElement') {
+                    extractIdentifiers(prop.argument, nodes);
+                }
+                else {
+                    extractIdentifiers(prop.value, nodes);
+                }
+            }
+            break;
+        case 'ArrayPattern':
+            param.elements.forEach(element => {
+                if (element)
+                    extractIdentifiers(element, nodes);
+            });
+            break;
+        case 'RestElement':
+            extractIdentifiers(param.argument, nodes);
+            break;
+        case 'AssignmentPattern':
+            extractIdentifiers(param.left, nodes);
+            break;
+    }
+    return nodes;
+}
+const isFunctionType = (node) => {
+    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+const isStaticProperty = (node) => node &&
+    (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
+    !node.computed;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
 const prohibitedKeywordRE = new RegExp('\\b' +
@@ -3966,7 +4069,10 @@ function buildProps(node, context, props = node.props, ssr = false) {
                         !isStaticExp(styleProp.value) &&
                         // the static style is compiled into an object,
                         // so use `hasStyleBinding` to ensure that it is a dynamic style binding
-                        hasStyleBinding) {
+                        (hasStyleBinding ||
+                            // v-bind:style and style both exist,
+                            // v-bind:style with static literal object
+                            styleProp.value.type === 17 /* JS_ARRAY_EXPRESSION */)) {
                         styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]);
                     }
                 }
@@ -4727,4 +4833,4 @@ function baseCompile(template, options = {}) {
 
 const noopDirectiveTransform = () => ({ props: [] });
 
-export { BASE_TRANSITION, CAMELIZE, CAPITALIZE, CREATE_BLOCK, CREATE_COMMENT, CREATE_ELEMENT_BLOCK, CREATE_ELEMENT_VNODE, CREATE_SLOTS, CREATE_STATIC, CREATE_TEXT, CREATE_VNODE, FRAGMENT, GUARD_REACTIVE_PROPS, IS_MEMO_SAME, IS_REF, KEEP_ALIVE, MERGE_PROPS, NORMALIZE_CLASS, NORMALIZE_PROPS, NORMALIZE_STYLE, OPEN_BLOCK, POP_SCOPE_ID, PUSH_SCOPE_ID, RENDER_LIST, RENDER_SLOT, RESOLVE_COMPONENT, RESOLVE_DIRECTIVE, RESOLVE_DYNAMIC_COMPONENT, RESOLVE_FILTER, SET_BLOCK_TRACKING, SUSPENSE, TELEPORT, TO_DISPLAY_STRING, TO_HANDLERS, TO_HANDLER_KEY, UNREF, WITH_CTX, WITH_DIRECTIVES, WITH_MEMO, WITH_SCOPE_ID, advancePositionWithClone, advancePositionWithMutation, assert, baseCompile, baseParse, buildProps, buildSlots, checkCompatEnabled, createArrayExpression, createAssignmentExpression, createBlockStatement, createCacheExpression, createCallExpression, createCompilerError, createCompoundExpression, createConditionalExpression, createForLoopParams, createFunctionExpression, createIfStatement, createInterpolation, createObjectExpression, createObjectProperty, createReturnStatement, createRoot, createSequenceExpression, createSimpleExpression, createStructuralDirectiveTransform, createTemplateLiteral, createTransformContext, createVNodeCall, findDir, findProp, generate, getBaseTransformPreset, getInnerRange, getMemoedVNodeCall, getVNodeBlockHelper, getVNodeHelper, hasDynamicKeyVBind, hasScopeRef, helperNameMap, injectProp, isBindKey, isBuiltInType, isCoreComponent, isMemberExpression, isSimpleIdentifier, isSlotOutlet, isStaticExp, isTemplateNode, isText, isVSlot, locStub, makeBlock, noopDirectiveTransform, processExpression, processFor, processIf, processSlotOutlet, registerRuntimeHelpers, resolveComponentType, toValidAssetId, trackSlotScopes, trackVForSlotScopes, transform, transformBind, transformElement, transformExpression, transformModel, transformOn, traverseNode, warnDeprecation };
+export { BASE_TRANSITION, CAMELIZE, CAPITALIZE, CREATE_BLOCK, CREATE_COMMENT, CREATE_ELEMENT_BLOCK, CREATE_ELEMENT_VNODE, CREATE_SLOTS, CREATE_STATIC, CREATE_TEXT, CREATE_VNODE, FRAGMENT, GUARD_REACTIVE_PROPS, IS_MEMO_SAME, IS_REF, KEEP_ALIVE, MERGE_PROPS, NORMALIZE_CLASS, NORMALIZE_PROPS, NORMALIZE_STYLE, OPEN_BLOCK, POP_SCOPE_ID, PUSH_SCOPE_ID, RENDER_LIST, RENDER_SLOT, RESOLVE_COMPONENT, RESOLVE_DIRECTIVE, RESOLVE_DYNAMIC_COMPONENT, RESOLVE_FILTER, SET_BLOCK_TRACKING, SUSPENSE, TELEPORT, TO_DISPLAY_STRING, TO_HANDLERS, TO_HANDLER_KEY, UNREF, WITH_CTX, WITH_DIRECTIVES, WITH_MEMO, WITH_SCOPE_ID, advancePositionWithClone, advancePositionWithMutation, assert, baseCompile, baseParse, buildProps, buildSlots, checkCompatEnabled, createArrayExpression, createAssignmentExpression, createBlockStatement, createCacheExpression, createCallExpression, createCompilerError, createCompoundExpression, createConditionalExpression, createForLoopParams, createFunctionExpression, createIfStatement, createInterpolation, createObjectExpression, createObjectProperty, createReturnStatement, createRoot, createSequenceExpression, createSimpleExpression, createStructuralDirectiveTransform, createTemplateLiteral, createTransformContext, createVNodeCall, extractIdentifiers, findDir, findProp, generate, getBaseTransformPreset, getInnerRange, getMemoedVNodeCall, getVNodeBlockHelper, getVNodeHelper, hasDynamicKeyVBind, hasScopeRef, helperNameMap, injectProp, isBindKey, isBuiltInType, isCoreComponent, isFunctionType, isInDestructureAssignment, isMemberExpression, isReferencedIdentifier, isSimpleIdentifier, isSlotOutlet, isStaticExp, isStaticProperty, isStaticPropertyKey, isTemplateNode, isText, isVSlot, locStub, makeBlock, noopDirectiveTransform, processExpression, processFor, processIf, processSlotOutlet, registerRuntimeHelpers, resolveComponentType, toValidAssetId, trackSlotScopes, trackVForSlotScopes, transform, transformBind, transformElement, transformExpression, transformModel, transformOn, traverseNode, walkBlockDeclarations, walkFunctionParams, walkIdentifiers, warnDeprecation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-core",
-  "version": "3.2.2",
+  "version": "3.2.6",
   "description": "@vue/compiler-core",
   "main": "index.js",
   "module": "dist/compiler-core.esm-bundler.js",
@@ -32,10 +32,10 @@
   },
   "homepage": "https://github.com/vuejs/vue-next/tree/master/packages/compiler-core#readme",
   "dependencies": {
-    "@vue/shared": "3.2.2",
-    "@babel/parser": "^7.12.0",
-    "@babel/types": "^7.12.0",
-    "estree-walker": "^2.0.1",
+    "@vue/shared": "3.2.6",
+    "@babel/parser": "^7.15.0",
+    "@babel/types": "^7.15.0",
+    "estree-walker": "^2.0.2",
     "source-map": "^0.6.1"
   }
 }