From 08ed6cf8bdeda6f7f55095bf127d23b54c69ab74 Mon Sep 17 00:00:00 2001 From: BigAru Date: Fri, 7 Dec 2018 14:46:42 +0100 Subject: [PATCH] optimize nodesToTemplate --- .../convertStringOrTemplateLiteral.ts | 62 +++++++++---------- 1 file changed, 29 insertions(+), 33 deletions(-) diff --git a/src/services/refactors/convertStringOrTemplateLiteral.ts b/src/services/refactors/convertStringOrTemplateLiteral.ts index eebb27c676c..7c9c191f4ea 100644 --- a/src/services/refactors/convertStringOrTemplateLiteral.ts +++ b/src/services/refactors/convertStringOrTemplateLiteral.ts @@ -48,7 +48,7 @@ namespace ts.refactor.convertStringOrTemplateLiteral { if (isParenthesizedExpression(node.parent) && isBinaryExpression(node.parent.parent)) node = node.parent.parent; const maybeBinary = getParentBinaryExpression(node); - const arrayOfNodes = treeToArray(maybeBinary)[0]; + const arrayOfNodes = transformTreeToArray(maybeBinary); const templateLiteral = nodesToTemplate(arrayOfNodes); const edits = textChanges.ChangeTracker.with(context, t => t.replaceNode(file, maybeBinary, templateLiteral)); return { edits }; @@ -73,7 +73,7 @@ namespace ts.refactor.convertStringOrTemplateLiteral { } }); - const binaryExpression = arrayToTree(nodesArray, /* binaryExpression*/ undefined); + const binaryExpression = arrayToTree(nodesArray); return { edits: textChanges.ChangeTracker.with(context, t => t.replaceNode(file, templateLiteralExpression, binaryExpression)) }; } @@ -91,10 +91,10 @@ namespace ts.refactor.convertStringOrTemplateLiteral { return expr; } - function arrayToTree(nodes: Expression[], bexpr: BinaryExpression | undefined): BinaryExpression { - if (nodes.length === 0) return bexpr!; + function arrayToTree(nodes: Expression[], accumulator?: BinaryExpression): BinaryExpression { + if (nodes.length === 0) return accumulator!; - if (bexpr === undefined) { + if (!accumulator) { const left = nodes[0]; const right = nodes[1]; @@ -103,7 +103,7 @@ namespace ts.refactor.convertStringOrTemplateLiteral { } const right = nodes[0]; - const binary = createBinary (bexpr, SyntaxKind.PlusToken, right); + const binary = createBinary(accumulator, SyntaxKind.PlusToken, right); return arrayToTree(nodes.slice(1), binary); } @@ -112,20 +112,24 @@ namespace ts.refactor.convertStringOrTemplateLiteral { return containsString && areOperatorsValid; } - function treeToArray(node: Node): [Node[], /* containsString */ boolean, /* areOperatorsValid */ boolean] { + function transformTreeToArray(node: Node): Expression[] { + return treeToArray(node)[0]; + } + + function treeToArray(node: Node): [Expression[], /* containsString */ boolean, /* areOperatorsValid */ boolean] { if (isBinaryExpression(node)) { - const [leftNodes, leftHasString, leftOp] = treeToArray(node.left); - const [rightNodes, rightHasString, rightOp] = treeToArray(node.right); + const [leftNodes, leftHasString, leftOperatorValid] = treeToArray(node.left); + const [rightNodes, rightHasString, rightOperatorValid] = treeToArray(node.right); if (!leftHasString && !rightHasString) return [[node], false, true]; - const currentOp = node.operatorToken.kind === SyntaxKind.PlusToken; - const isPlus = leftOp && currentOp && rightOp; + const nodeOperatorValid = node.operatorToken.kind === SyntaxKind.PlusToken; + const isPlus = leftOperatorValid && nodeOperatorValid && rightOperatorValid; return [leftNodes.concat(rightNodes), true, isPlus]; } - return [[node], isStringLiteral(node), true]; + return [[node as Expression], isStringLiteral(node), true]; } function createHead(nodes: Node[]): [number, TemplateHead] { @@ -142,8 +146,8 @@ namespace ts.refactor.convertStringOrTemplateLiteral { return [begin, head]; } - function nodesToTemplate(nodes: Node[]) { - const spans: TemplateSpan[] = []; + function nodesToTemplate(nodes: Expression[]) { + const templateSpans: TemplateSpan[] = []; const [begin, head] = createHead(nodes); if (begin === nodes.length) { @@ -152,35 +156,27 @@ namespace ts.refactor.convertStringOrTemplateLiteral { for (let i = begin; i < nodes.length; i++) { let current = nodes[i]; - let templatePart: TemplateMiddle | TemplateTail; + let text = ""; - if (i + 1 < nodes.length && isStringLiteral(nodes[i + 1])) { - let next = nodes[i + 1] as StringLiteral; - let text = next.text; + while (i + 1 < nodes.length && isStringLiteral(nodes[i + 1])) { + const next = nodes[i + 1] as StringLiteral; + text = text + next.text; i++; - - while (i + 1 < nodes.length && isStringLiteral(nodes[i + 1])) { - next = nodes[i + 1] as StringLiteral; - text = text + next.text; - i++; - } - - text = escapeText(text); - templatePart = i === nodes.length - 1 ? createTemplateTail(text) : createTemplateMiddle(text); - } - else { - templatePart = i === nodes.length - 1 ? createTemplateTail("") : createTemplateMiddle(""); } + text = escapeText(text); + const templatePart = i === nodes.length - 1 ? createTemplateTail(text) : createTemplateMiddle(text); + if (isParenthesizedExpression(current)) current = current.expression; - spans.push(createTemplateSpan(current as Expression, templatePart)); + templateSpans.push(createTemplateSpan(current, templatePart)); } - return createTemplateExpression(head, spans); + return createTemplateExpression(head, templateSpans); } function escapeText(content: string) { - return content.replace("`", "\`").replace("\${", `$\\{`); + return content.replace("`", "\`") + .replace("\${", `$\\{`); } }