fix: support capturing only name of type parameters

Author: jedwards1211

package.json

@@ -220,7 +220,7 @@
     "resolve": "^1.19.0",
     "shallowequal": "^1.1.0",
     "tiny-typed-emitter": "^2.1.0",
-    "ts-node": "^9.1.1",
+    "ts-node": "^10.9.1",
     "typed-validators": "^4.5.1",
     "yargs": "^17.6.2"
   }

pnpm-lock.yaml

@@ -1,4 +1,4 @@
-import { Identifier, NodePath } from '../types'
+import { Identifier, NodePath, setAstxMatchInfo } from '../types'
 import compileMatcher, { CompiledMatcher, CompileOptions, MatchResult } from '.'
 import compilePlaceholderMatcher, { unescapeIdentifier } from './Placeholder'
 
@@ -71,9 +71,12 @@ export default function compileIdentifierMatcher(
             : null
 
           if (captured) {
-            ;(captured.node as any).astx = {
-              excludeTypeAnnotationFromCapture: true,
-            }
+            setAstxMatchInfo(captured.node, {
+              subcapture: {
+                type: 'Identifier',
+                name: (captured.node as Identifier).name,
+              },
+            })
           }
 
           return typeAnnotationMatcher.match(

src/compileMatcher/Identifier.ts

@@ -1,21 +1,53 @@
-import { TSTypeParameter, NodePath } from '../types'
-import { CompiledMatcher, CompileOptions } from '.'
+import { TSTypeParameter, NodePath, setAstxMatchInfo } from '../types'
+import { CompiledMatcher, CompileOptions, MatchResult } from '.'
 import compilePlaceholderMatcher from './Placeholder'
+import compileGenericNodeMatcher from './GenericNodeMatcher'
 
 export default function compileTSTypeParameterMatcher(
   path: NodePath<TSTypeParameter, TSTypeParameter>,
   compileOptions: CompileOptions
 ): CompiledMatcher | void {
   const pattern: TSTypeParameter = path.value
 
-  if (pattern.constraint == null && pattern.default == null) {
-    const placeholderMatcher = compilePlaceholderMatcher(
-      path,
-      pattern.name,
-      compileOptions,
-      { nodeType: 'TSTypeParameter' }
-    )
+  const placeholderMatcher = compilePlaceholderMatcher(
+    path,
+    pattern.name,
+    compileOptions,
+    { nodeType: 'TSTypeParameter' }
+  )
 
-    if (placeholderMatcher) return placeholderMatcher
+  if (placeholderMatcher) {
+    if (pattern.constraint == null && pattern.default == null) {
+      return placeholderMatcher
+    }
+
+    const { placeholder } = placeholderMatcher
+
+    const genericMatcher = compileGenericNodeMatcher(path, compileOptions, {
+      keyMatchers: { name: placeholderMatcher },
+    })
+
+    return {
+      ...genericMatcher,
+
+      match: (path: NodePath, matchSoFar: MatchResult): MatchResult => {
+        matchSoFar = genericMatcher.match(path, matchSoFar)
+
+        if (matchSoFar == null) return null
+
+        const captured = placeholder ? matchSoFar.captures?.[placeholder] : null
+
+        if (captured) {
+          setAstxMatchInfo(captured.node, {
+            subcapture: {
+              type: 'TSTypeParameter',
+              name: (captured.node as TSTypeParameter).name,
+            },
+          })
+        }
+
+        return matchSoFar
+      },
+    }
   }
 }

src/compileMatcher/TSTypeParameter.ts

@@ -1,21 +1,53 @@
-import { TypeParameter, NodePath } from '../types'
-import { CompiledMatcher, CompileOptions } from '.'
+import { TypeParameter, NodePath, setAstxMatchInfo } from '../types'
+import { CompiledMatcher, CompileOptions, MatchResult } from '.'
 import compilePlaceholderMatcher from './Placeholder'
+import compileGenericNodeMatcher from './GenericNodeMatcher'
 
 export default function compileTypeParameterMatcher(
   path: NodePath<TypeParameter, TypeParameter>,
   compileOptions: CompileOptions
 ): CompiledMatcher | void {
   const pattern: TypeParameter = path.value
 
-  if (pattern.variance == null && pattern.bound == null) {
-    const placeholderMatcher = compilePlaceholderMatcher(
-      path,
-      pattern.name,
-      compileOptions,
-      { nodeType: 'TypeParameter' }
-    )
+  const placeholderMatcher = compilePlaceholderMatcher(
+    path,
+    pattern.name,
+    compileOptions,
+    { nodeType: 'TypeParameter' }
+  )
 
-    if (placeholderMatcher) return placeholderMatcher
+  if (placeholderMatcher) {
+    if (pattern.variance == null && pattern.bound == null) {
+      return placeholderMatcher
+    }
+
+    const { placeholder } = placeholderMatcher
+
+    const genericMatcher = compileGenericNodeMatcher(path, compileOptions, {
+      keyMatchers: { name: placeholderMatcher },
+    })
+
+    return {
+      ...genericMatcher,
+
+      match: (path: NodePath, matchSoFar: MatchResult): MatchResult => {
+        matchSoFar = genericMatcher.match(path, matchSoFar)
+
+        if (matchSoFar == null) return null
+
+        const captured = placeholder ? matchSoFar.captures?.[placeholder] : null
+
+        if (captured) {
+          setAstxMatchInfo(captured.node, {
+            subcapture: {
+              type: 'TypeParameter',
+              name: (captured.node as TypeParameter).name,
+            },
+          })
+        }
+
+        return matchSoFar
+      },
+    }
   }
 }

src/compileMatcher/TypeParameter.ts

@@ -3,7 +3,7 @@ import {
   CompiledReplacement,
   ReplaceableMatch,
 } from '.'
-import { Node, NodePath } from '../types'
+import { Node, NodePath, getAstxMatchInfo } from '../types'
 import {
   getArrayPlaceholder,
   getPlaceholder,
@@ -55,8 +55,8 @@ export default function compilePlaceholderReplacement(
         const capture = match.captures?.[placeholder]
         if (capture) {
           const clone = cloneNode(capture)
-          if ((capture as any).astx?.excludeTypeAnnotationFromCapture)
-            delete (clone as any).typeAnnotation
+          const astx = getAstxMatchInfo(capture)
+          if (astx?.subcapture) return convertReplacement(astx.subcapture)
           return convertReplacement(clone)
         }
         return convertReplacement(cloneNode(pattern.value))

src/compileReplacement/Placeholder.ts

@@ -4,6 +4,30 @@ import * as k from 'ast-types/gen/kinds'
 
 type ArrayElement<A> = A extends readonly (infer T)[] ? T : never
 
+export type AstxMatchInfo = {
+  /**
+   * Used for cases like when capturing only the name of an identifier with a type annotation
+   * like `$a: number`.  The name property isn't a node, so we have to capture the Identifier
+   * node, which includes the `number` TypeAnnotation.  But we don't want the TypeAnnotation
+   * to be included when interpolating the capture in replcements, so we set a `subcapture`
+   * that's a copy of the Identifier without the TypeAnnotation, and when replacing, we use
+   * any `subcapture` in place of the captured node.
+   */
+  subcapture?: Node
+}
+
+export function getAstxMatchInfo(node: Node): AstxMatchInfo | undefined {
+  return (node as any).astx
+}
+
+export function setAstxMatchInfo(
+  node: Node,
+  info: AstxMatchInfo | undefined
+): void {
+  if (!info) delete (node as any).astx
+  else (node as any).astx = info
+}
+
 export type Location = {
   start?: number | null
   end?: number | null