fix: allow string literals and template literals without expressions to match

Author: jedwards1211

src/compileMatcher/Placeholder.ts

@@ -151,26 +151,27 @@ export default function compilePlaceholderMatcher(
   )
 }
 
+function getString(node: Node): string | undefined {
+  if (node.type === 'StringLiteral') return node.value
+  if (node.type === 'TemplateLiteral' && node.quasis.length === 1)
+    return node.quasis[0].value.cooked ?? node.quasis[0].value.raw
+  return undefined
+}
+
 export function compileStringPlaceholderMatcher<N extends Node>(
   pattern: NodePath<N>,
-  getString: (node: N) => string | null,
-  compileOptions: CompileOptions,
-  otherOptions?: {
-    nodeType?: NodeType | NodeType[]
-  }
+  compileOptions: CompileOptions
 ): CompiledMatcher | void {
   const { debug } = compileOptions
   const string = getString(pattern.value)
   if (!string) return
   const placeholder = getPlaceholder(string)
-  const nodeType = otherOptions?.nodeType
   if (placeholder) {
     return {
       pattern,
       placeholder,
-      nodeType,
+      nodeType: ['StringLiteral', 'TemplateLiteral'],
       match: (path: NodePath, matchSoFar: MatchResult): MatchResult => {
-        if (path.value?.type !== pattern.value.type) return null
         debug('String Placeholder', placeholder)
         const string = getString((path as NodePath<N>).value)
         if (!string) return null

src/compileMatcher/StringLiteral.ts

@@ -10,27 +10,38 @@ export default function matchStringLiteral(
   compileOptions: CompileOptions
 ): CompiledMatcher {
   const pattern: StringLiteral = path.value
-  const n = compileOptions.backend.t.namedTypes
   const placeholderMatcher = compileStringPlaceholderMatcher(
     path,
-    (pattern) => pattern.value,
-    compileOptions,
-    { nodeType: 'StringLiteral' }
+    compileOptions
   )
 
   if (placeholderMatcher) return placeholderMatcher
 
   pattern.value = unescapeIdentifier(pattern.value)
 
+  return createStringLiteralMatcher(path, pattern.value, compileOptions)
+}
+
+export function createStringLiteralMatcher(
+  path: NodePath,
+  value: string,
+  compileOptions: CompileOptions
+): CompiledMatcher {
+  const n = compileOptions.backend.t.namedTypes
   return convertPredicateMatcher(
     path,
     {
       match: (path: NodePath): boolean => {
         const { value: node } = path
 
-        return n.StringLiteral.check(node) && pattern.value === node.value
+        return (
+          (n.StringLiteral.check(node) && value === node.value) ||
+          (n.TemplateLiteral.check(node) &&
+            node.quasis.length === 1 &&
+            value === (node.quasis[0].value.cooked ?? node.quasis[0].value.raw))
+        )
       },
-      nodeType: 'StringLiteral',
+      nodeType: ['StringLiteral', 'TemplateLiteral'],
     },
     compileOptions
   )

src/compileMatcher/TemplateLiteral.ts

@@ -4,6 +4,7 @@ import {
   compileStringPlaceholderMatcher,
   unescapeIdentifier,
 } from './Placeholder'
+import { createStringLiteralMatcher } from './StringLiteral'
 
 function generateValue(cooked: string): { raw: string; cooked: string } {
   return { raw: cooked.replace(/\\|`|\${/g, '\\$&'), cooked }
@@ -17,10 +18,7 @@ export default function matchTemplateLiteral(
 
   const placeholderMatcher = compileStringPlaceholderMatcher(
     path,
-    (node: TemplateLiteral) =>
-      node.quasis.length === 1 ? node.quasis[0].value.cooked ?? null : null,
-    compileOptions,
-    { nodeType: 'TemplateLiteral' }
+    compileOptions
   )
 
   if (placeholderMatcher) return placeholderMatcher
@@ -33,5 +31,10 @@ export default function matchTemplateLiteral(
         quasi.value = generateValue(unescaped)
       }
     }
+    return createStringLiteralMatcher(
+      path,
+      quasi.value.cooked ?? quasi.value.raw,
+      compileOptions
+    )
   }
 }

test/findReplace/backtickStringMatchesStringLiteral.ts

@@ -0,0 +1,15 @@
+import { findReplaceTestcase } from '../findReplaceTestcase'
+import dedent from 'dedent-js'
+
+findReplaceTestcase({
+  file: __filename,
+  input: dedent`
+    'foo'
+    \`foo\`
+    'bar'
+  `,
+  find: dedent`
+    \`foo\`
+  `,
+  expectedFind: [{ node: "'foo'" }, { node: '`foo`' }],
+})

test/findReplace/backtickStringPlaceholderMatchesString.ts

@@ -0,0 +1,18 @@
+import { findReplaceTestcase } from '../findReplaceTestcase'
+import dedent from 'dedent-js'
+
+findReplaceTestcase({
+  file: __filename,
+  input: dedent`
+    'foo'
+    \`bar\`
+  `,
+  find: dedent`
+    \`$s\`
+  `,
+  expectedFind: ["'foo'", '`bar`'].map((node) => ({
+    node,
+    captures: { $s: node },
+    stringCaptures: { $s: node.substring(1, node.length - 1) },
+  })),
+})

test/findReplace/stringLiteralMatchesBacktickString.ts

@@ -0,0 +1,16 @@
+import { findReplaceTestcase } from '../findReplaceTestcase'
+import dedent from 'dedent-js'
+
+findReplaceTestcase({
+  file: __filename,
+  input: dedent`
+    'foo'
+    \`foo\`
+    \`foo\${a}\`
+    \`bar\`
+  `,
+  find: dedent`
+    'foo' 
+  `,
+  expectedFind: [{ node: "'foo'" }, { node: '`foo`' }],
+})

test/findReplace/stringPlaceholderMatchesBacktickString.ts

@@ -0,0 +1,19 @@
+import { findReplaceTestcase } from '../findReplaceTestcase'
+import dedent from 'dedent-js'
+
+findReplaceTestcase({
+  file: __filename,
+  input: dedent`
+    'foo'
+    \`bar\`
+    \`bar\${baz}\`
+  `,
+  find: dedent`
+    '$s' 
+  `,
+  expectedFind: ["'foo'", '`bar`'].map((node) => ({
+    node,
+    captures: { $s: node },
+    stringCaptures: { $s: node.substring(1, node.length - 1) },
+  })),
+})