1 line
24 KiB
Plaintext
1 line
24 KiB
Plaintext
{"version":3,"names":["isArrayTypeAnnotation","isArrowFunctionExpression","isAssignmentExpression","isAwaitExpression","isBinary","isBinaryExpression","isUpdateExpression","isCallExpression","isClass","isClassExpression","isConditional","isConditionalExpression","isExportDeclaration","isExportDefaultDeclaration","isExpressionStatement","isFor","isForInStatement","isForOfStatement","isForStatement","isFunctionExpression","isIfStatement","isIndexedAccessType","isIntersectionTypeAnnotation","isLogicalExpression","isMemberExpression","isNewExpression","isNullableTypeAnnotation","isObjectPattern","isOptionalCallExpression","isOptionalMemberExpression","isReturnStatement","isSequenceExpression","isSwitchStatement","isTSArrayType","isTSAsExpression","isTSInstantiationExpression","isTSIntersectionType","isTSNonNullExpression","isTSOptionalType","isTSRestType","isTSTypeAssertion","isTSUnionType","isTaggedTemplateExpression","isThrowStatement","isTypeAnnotation","isUnaryLike","isUnionTypeAnnotation","isVariableDeclarator","isWhileStatement","isYieldExpression","PRECEDENCE","in","instanceof","isClassExtendsClause","node","parent","superClass","hasPostfixPart","object","callee","tag","NullableTypeAnnotation","FunctionTypeAnnotation","printStack","length","UpdateExpression","ObjectExpression","isFirstInContext","DoExpression","async","Binary","operator","left","parentOp","parentPos","nodeOp","nodePos","right","UnionTypeAnnotation","OptionalIndexedAccessType","objectType","TSAsExpression","TSTypeAssertion","TSUnionType","TSInferType","TSInstantiationExpression","typeParameters","BinaryExpression","SequenceExpression","test","discriminant","expression","YieldExpression","ClassExpression","UnaryLike","FunctionExpression","ArrowFunctionExpression","ConditionalExpression","OptionalMemberExpression","AssignmentExpression","LogicalExpression","Identifier","extra","parenthesized","id","name","isFollowedByBracket","computed","optional","checkParam","expressionStatement","arrowBody","exportDefault","forHead","forInHead","forOfHead","i","declaration","body","init","expressions","prefix"],"sources":["../../src/node/parentheses.ts"],"sourcesContent":["import {\n isArrayTypeAnnotation,\n isArrowFunctionExpression,\n isAssignmentExpression,\n isAwaitExpression,\n isBinary,\n isBinaryExpression,\n isUpdateExpression,\n isCallExpression,\n isClass,\n isClassExpression,\n isConditional,\n isConditionalExpression,\n isExportDeclaration,\n isExportDefaultDeclaration,\n isExpressionStatement,\n isFor,\n isForInStatement,\n isForOfStatement,\n isForStatement,\n isFunctionExpression,\n isIfStatement,\n isIndexedAccessType,\n isIntersectionTypeAnnotation,\n isLogicalExpression,\n isMemberExpression,\n isNewExpression,\n isNullableTypeAnnotation,\n isObjectPattern,\n isOptionalCallExpression,\n isOptionalMemberExpression,\n isReturnStatement,\n isSequenceExpression,\n isSwitchStatement,\n isTSArrayType,\n isTSAsExpression,\n isTSInstantiationExpression,\n isTSIntersectionType,\n isTSNonNullExpression,\n isTSOptionalType,\n isTSRestType,\n isTSTypeAssertion,\n isTSUnionType,\n isTaggedTemplateExpression,\n isThrowStatement,\n isTypeAnnotation,\n isUnaryLike,\n isUnionTypeAnnotation,\n isVariableDeclarator,\n isWhileStatement,\n isYieldExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nconst PRECEDENCE = {\n \"||\": 0,\n \"??\": 0,\n \"|>\": 0,\n \"&&\": 1,\n \"|\": 2,\n \"^\": 3,\n \"&\": 4,\n \"==\": 5,\n \"===\": 5,\n \"!=\": 5,\n \"!==\": 5,\n \"<\": 6,\n \">\": 6,\n \"<=\": 6,\n \">=\": 6,\n in: 6,\n instanceof: 6,\n \">>\": 7,\n \"<<\": 7,\n \">>>\": 7,\n \"+\": 8,\n \"-\": 8,\n \"*\": 9,\n \"/\": 9,\n \"%\": 9,\n \"**\": 10,\n};\n\nconst enum CheckParam {\n expressionStatement = 1 << 0,\n arrowBody = 1 << 1,\n exportDefault = 1 << 2,\n forHead = 1 << 3,\n forInHead = 1 << 4,\n forOfHead = 1 << 5,\n}\n\nconst isClassExtendsClause = (\n node: t.Node,\n parent: t.Node,\n): parent is t.Class => isClass(parent, { superClass: node });\n\nconst hasPostfixPart = (node: t.Node, parent: t.Node) =>\n ((isMemberExpression(parent) || isOptionalMemberExpression(parent)) &&\n parent.object === node) ||\n ((isCallExpression(parent) ||\n isOptionalCallExpression(parent) ||\n isNewExpression(parent)) &&\n parent.callee === node) ||\n (isTaggedTemplateExpression(parent) && parent.tag === node) ||\n isTSNonNullExpression(parent);\n\nexport function NullableTypeAnnotation(\n node: t.NullableTypeAnnotation,\n parent: t.Node,\n): boolean {\n return isArrayTypeAnnotation(parent);\n}\n\nexport function FunctionTypeAnnotation(\n node: t.FunctionTypeAnnotation,\n parent: t.Node,\n printStack: Array<t.Node>,\n): boolean {\n if (printStack.length < 3) return;\n\n return (\n // (() => A) | (() => B)\n isUnionTypeAnnotation(parent) ||\n // (() => A) & (() => B)\n isIntersectionTypeAnnotation(parent) ||\n // (() => A)[]\n isArrayTypeAnnotation(parent) ||\n // <T>(A: T): (T => T[]) => B => [A, B]\n (isTypeAnnotation(parent) &&\n // Check grandparent\n isArrowFunctionExpression(printStack[printStack.length - 3]))\n );\n}\n\nexport function UpdateExpression(\n node: t.UpdateExpression,\n parent: t.Node,\n): boolean {\n return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);\n}\n\nexport function ObjectExpression(\n node: t.ObjectExpression,\n parent: t.Node,\n printStack: Array<t.Node>,\n): boolean {\n return isFirstInContext(\n printStack,\n CheckParam.expressionStatement | CheckParam.arrowBody,\n );\n}\n\nexport function DoExpression(\n node: t.DoExpression,\n parent: t.Node,\n printStack: Array<t.Node>,\n): boolean {\n // `async do` can start an expression statement\n return (\n !node.async && isFirstInContext(printStack, CheckParam.expressionStatement)\n );\n}\n\nexport function Binary(node: t.BinaryExpression, parent: t.Node): boolean {\n if (\n node.operator === \"**\" &&\n isBinaryExpression(parent, { operator: \"**\" })\n ) {\n return parent.left === node;\n }\n\n if (isClassExtendsClause(node, parent)) {\n return true;\n }\n\n if (\n hasPostfixPart(node, parent) ||\n isUnaryLike(parent) ||\n isAwaitExpression(parent)\n ) {\n return true;\n }\n\n if (isBinary(parent)) {\n const parentOp = parent.operator;\n const parentPos = PRECEDENCE[parentOp];\n\n const nodeOp = node.operator;\n const nodePos = PRECEDENCE[nodeOp];\n\n if (\n // Logical expressions with the same precedence don't need parens.\n (parentPos === nodePos &&\n parent.right === node &&\n !isLogicalExpression(parent)) ||\n parentPos > nodePos\n ) {\n return true;\n }\n }\n}\n\nexport function UnionTypeAnnotation(\n node: t.UnionTypeAnnotation,\n parent: t.Node,\n): boolean {\n return (\n isArrayTypeAnnotation(parent) ||\n isNullableTypeAnnotation(parent) ||\n isIntersectionTypeAnnotation(parent) ||\n isUnionTypeAnnotation(parent)\n );\n}\n\nexport { UnionTypeAnnotation as IntersectionTypeAnnotation };\n\nexport function OptionalIndexedAccessType(\n node: t.OptionalIndexedAccessType,\n parent: t.Node,\n): boolean {\n return isIndexedAccessType(parent, { objectType: node });\n}\n\nexport function TSAsExpression() {\n return true;\n}\n\nexport function TSTypeAssertion() {\n return true;\n}\n\nexport function TSUnionType(node: t.TSUnionType, parent: t.Node): boolean {\n return (\n isTSArrayType(parent) ||\n isTSOptionalType(parent) ||\n isTSIntersectionType(parent) ||\n isTSUnionType(parent) ||\n isTSRestType(parent)\n );\n}\n\nexport { TSUnionType as TSIntersectionType };\n\nexport function TSInferType(node: t.TSInferType, parent: t.Node): boolean {\n return isTSArrayType(parent) || isTSOptionalType(parent);\n}\n\nexport function TSInstantiationExpression(\n node: t.TSInstantiationExpression,\n parent: t.Node,\n) {\n return (\n (isCallExpression(parent) ||\n isOptionalCallExpression(parent) ||\n isNewExpression(parent) ||\n isTSInstantiationExpression(parent)) &&\n !!parent.typeParameters\n );\n}\n\nexport function BinaryExpression(\n node: t.BinaryExpression,\n parent: t.Node,\n): boolean {\n // let i = (1 in []);\n // for ((1 in []);;);\n return (\n node.operator === \"in\" && (isVariableDeclarator(parent) || isFor(parent))\n );\n}\n\nexport function SequenceExpression(\n node: t.SequenceExpression,\n parent: t.Node,\n): boolean {\n if (\n // Although parentheses wouldn\"t hurt around sequence\n // expressions in the head of for loops, traditional style\n // dictates that e.g. i++, j++ should not be wrapped with\n // parentheses.\n isForStatement(parent) ||\n isThrowStatement(parent) ||\n isReturnStatement(parent) ||\n (isIfStatement(parent) && parent.test === node) ||\n (isWhileStatement(parent) && parent.test === node) ||\n (isForInStatement(parent) && parent.right === node) ||\n (isSwitchStatement(parent) && parent.discriminant === node) ||\n (isExpressionStatement(parent) && parent.expression === node)\n ) {\n return false;\n }\n\n // Otherwise err on the side of overparenthesization, adding\n // explicit exceptions above if this proves overzealous.\n return true;\n}\n\nexport function YieldExpression(\n node: t.YieldExpression,\n parent: t.Node,\n): boolean {\n return (\n isBinary(parent) ||\n isUnaryLike(parent) ||\n hasPostfixPart(node, parent) ||\n (isAwaitExpression(parent) && isYieldExpression(node)) ||\n (isConditionalExpression(parent) && node === parent.test) ||\n isClassExtendsClause(node, parent)\n );\n}\n\nexport { YieldExpression as AwaitExpression };\n\nexport function ClassExpression(\n node: t.ClassExpression,\n parent: t.Node,\n printStack: Array<t.Node>,\n): boolean {\n return isFirstInContext(\n printStack,\n CheckParam.expressionStatement | CheckParam.exportDefault,\n );\n}\n\nexport function UnaryLike(\n node:\n | t.UnaryLike\n | t.ArrowFunctionExpression\n | t.ConditionalExpression\n | t.AssignmentExpression,\n parent: t.Node,\n): boolean {\n return (\n hasPostfixPart(node, parent) ||\n isBinaryExpression(parent, { operator: \"**\", left: node }) ||\n isClassExtendsClause(node, parent)\n );\n}\n\nexport function FunctionExpression(\n node: t.FunctionExpression,\n parent: t.Node,\n printStack: Array<t.Node>,\n): boolean {\n return isFirstInContext(\n printStack,\n CheckParam.expressionStatement | CheckParam.exportDefault,\n );\n}\n\nexport function ArrowFunctionExpression(\n node: t.ArrowFunctionExpression,\n parent: t.Node,\n): boolean {\n return isExportDeclaration(parent) || ConditionalExpression(node, parent);\n}\n\nexport function ConditionalExpression(\n node:\n | t.ConditionalExpression\n | t.ArrowFunctionExpression\n | t.AssignmentExpression,\n parent?: t.Node,\n): boolean {\n if (\n isUnaryLike(parent) ||\n isBinary(parent) ||\n isConditionalExpression(parent, { test: node }) ||\n isAwaitExpression(parent) ||\n isTSTypeAssertion(parent) ||\n isTSAsExpression(parent)\n ) {\n return true;\n }\n\n return UnaryLike(node, parent);\n}\n\nexport function OptionalMemberExpression(\n node: t.OptionalMemberExpression,\n parent: t.Node,\n): boolean {\n return (\n isCallExpression(parent, { callee: node }) ||\n isMemberExpression(parent, { object: node })\n );\n}\n\nexport { OptionalMemberExpression as OptionalCallExpression };\n\nexport function AssignmentExpression(\n node: t.AssignmentExpression,\n parent: t.Node,\n): boolean {\n if (isObjectPattern(node.left)) {\n return true;\n } else {\n return ConditionalExpression(node, parent);\n }\n}\n\nexport function LogicalExpression(\n node: t.LogicalExpression,\n parent: t.Node,\n): boolean {\n switch (node.operator) {\n case \"||\":\n if (!isLogicalExpression(parent)) return false;\n return parent.operator === \"??\" || parent.operator === \"&&\";\n case \"&&\":\n return isLogicalExpression(parent, { operator: \"??\" });\n case \"??\":\n return isLogicalExpression(parent) && parent.operator !== \"??\";\n }\n}\n\nexport function Identifier(\n node: t.Identifier,\n parent: t.Node,\n printStack: Array<t.Node>,\n): boolean {\n // 13.15.2 AssignmentExpression RS: Evaluation\n // (fn) = function () {};\n if (\n node.extra?.parenthesized &&\n isAssignmentExpression(parent, { left: node }) &&\n (isFunctionExpression(parent.right) || isClassExpression(parent.right)) &&\n parent.right.id == null\n ) {\n return true;\n }\n // Non-strict code allows the identifier `let`, but it cannot occur as-is in\n // certain contexts to avoid ambiguity with contextual keyword `let`.\n if (node.name === \"let\") {\n // Some contexts only forbid `let [`, so check if the next token would\n // be the left bracket of a computed member expression.\n const isFollowedByBracket =\n isMemberExpression(parent, {\n object: node,\n computed: true,\n }) ||\n isOptionalMemberExpression(parent, {\n object: node,\n computed: true,\n optional: false,\n });\n return isFirstInContext(\n printStack,\n isFollowedByBracket\n ? CheckParam.expressionStatement |\n CheckParam.forHead |\n CheckParam.forInHead |\n CheckParam.forOfHead\n : CheckParam.forOfHead,\n );\n }\n\n // ECMAScript specifically forbids a for-of loop from starting with the\n // token sequence `for (async of`, because it would be ambiguous with\n // `for (async of => {};;)`, so we need to add extra parentheses.\n //\n // If the parent is a for-await-of loop (i.e. parent.await === true), the\n // parentheses aren't strictly needed, but we add them anyway because\n // some tools (including earlier Babel versions) can't parse\n // `for await (async of [])` without them.\n return (\n node.name === \"async\" && isForOfStatement(parent) && node === parent.left\n );\n}\n\n// Walk up the print stack to determine if our node can come first\n// in a particular context.\nfunction isFirstInContext(\n printStack: Array<t.Node>,\n checkParam: CheckParam,\n): boolean {\n const expressionStatement = checkParam & CheckParam.expressionStatement;\n const arrowBody = checkParam & CheckParam.arrowBody;\n const exportDefault = checkParam & CheckParam.exportDefault;\n const forHead = checkParam & CheckParam.forHead;\n const forInHead = checkParam & CheckParam.forInHead;\n const forOfHead = checkParam & CheckParam.forOfHead;\n\n let i = printStack.length - 1;\n if (i <= 0) return;\n let node = printStack[i];\n i--;\n let parent = printStack[i];\n while (i >= 0) {\n if (\n (expressionStatement &&\n isExpressionStatement(parent, { expression: node })) ||\n (exportDefault &&\n isExportDefaultDeclaration(parent, { declaration: node })) ||\n (arrowBody && isArrowFunctionExpression(parent, { body: node })) ||\n (forHead && isForStatement(parent, { init: node })) ||\n (forInHead && isForInStatement(parent, { left: node })) ||\n (forOfHead && isForOfStatement(parent, { left: node }))\n ) {\n return true;\n }\n\n if (\n i > 0 &&\n ((hasPostfixPart(node, parent) && !isNewExpression(parent)) ||\n (isSequenceExpression(parent) && parent.expressions[0] === node) ||\n (isUpdateExpression(parent) && !parent.prefix) ||\n isConditional(parent, { test: node }) ||\n isBinary(parent, { left: node }) ||\n isAssignmentExpression(parent, { left: node }))\n ) {\n node = parent;\n i--;\n parent = printStack[i];\n } else {\n return false;\n }\n }\n\n return false;\n}\n"],"mappings":"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"} |