perf(weapp-tailwindcss): 复用标签忽略判定上下文

Author: sonofmagic

packages/weapp-tailwindcss/src/js/taggedTemplateIgnore.ts

@@ -17,22 +17,26 @@ export function createTaggedTemplateIgnore(
 ): TaggedTemplateIgnore {
   const bindingIgnoreCache = new Map<Binding, boolean>()
   const taggedTemplateIgnoreCache = new WeakMap<Node, boolean>()
+  const seenBindings = new Set<Binding>()
   const canonicalIgnoreNames = new Set(
     (names ?? [])
       .filter((item): item is string => typeof item === 'string'),
   )
+  const hasCanonicalIgnoreNames = canonicalIgnoreNames.size > 0
+
+  const matchesIgnoreName = (value: string): boolean => {
+    return (hasCanonicalIgnoreNames && canonicalIgnoreNames.has(value)) || matcher(value)
+  }
 
   const propertyMatches = (propertyPath: NodePath<Node> | undefined): boolean => {
     if (!propertyPath) {
       return false
     }
     if (propertyPath.isIdentifier()) {
-      const { name } = propertyPath.node
-      return canonicalIgnoreNames.has(name) || matcher(name)
+      return matchesIgnoreName(propertyPath.node.name)
     }
     if (propertyPath.isStringLiteral()) {
-      const { value } = propertyPath.node
-      return canonicalIgnoreNames.has(value) || matcher(value)
+      return matchesIgnoreName(propertyPath.node.value)
     }
     return false
   }
@@ -72,10 +76,10 @@ export function createTaggedTemplateIgnore(
 
     if (bindingPath.isImportSpecifier()) {
       const imported = bindingPath.node.imported
-      if (imported.type === 'Identifier' && (canonicalIgnoreNames.has(imported.name) || matcher(imported.name))) {
+      if (imported.type === 'Identifier' && matchesIgnoreName(imported.name)) {
         result = true
       }
-      else if (imported.type === 'StringLiteral' && (canonicalIgnoreNames.has(imported.value) || matcher(imported.value))) {
+      else if (imported.type === 'StringLiteral' && matchesIgnoreName(imported.value)) {
         result = true
       }
     }
@@ -120,7 +124,7 @@ export function createTaggedTemplateIgnore(
       }
       if (current.isSequenceExpression()) {
         const expressions = current.get('expressions') as NodePath<Node>[]
-        const last = expressions[expressions.length - 1]
+        const last = expressions.at(-1)
         if (last) {
           current = last
           continue
@@ -136,25 +140,25 @@ export function createTaggedTemplateIgnore(
     return current
   }
 
-  const evaluateTagPath = (tagPath: NodePath<Node>): boolean => {
+  const evaluateTagPath = (tagPath: NodePath<Node>, seen: Set<Binding>): boolean => {
     if (tagPath.isCallExpression?.() || tagPath.node.type === 'CallExpression') {
       const calleePath = tagPath.get('callee') as NodePath<Node>
-      return evaluateTagPath(calleePath)
+      return evaluateTagPath(calleePath, seen)
     }
 
     if (tagPath.isIdentifier()) {
-      if (matcher(tagPath.node.name)) {
+      if (matchesIgnoreName(tagPath.node.name)) {
         return true
       }
       const binding = (tagPath as any)?.scope?.getBinding?.(tagPath.node.name)
       if (binding) {
-        return resolvesToWeappTwIgnore(binding, new Set())
+        return resolvesToWeappTwIgnore(binding, seen)
       }
       return false
     }
 
     if (tagPath.isMemberExpression()) {
-      return resolvesMemberExpressionToIgnore(tagPath as NodePath<MemberExpression>, new Set())
+      return resolvesMemberExpressionToIgnore(tagPath as NodePath<MemberExpression>, seen)
     }
 
     return false
@@ -173,7 +177,8 @@ export function createTaggedTemplateIgnore(
       return effectiveCached
     }
 
-    const result = evaluateTagPath(effectiveTagPath)
+    seenBindings.clear()
+    const result = evaluateTagPath(effectiveTagPath, seenBindings)
     taggedTemplateIgnoreCache.set(effectiveTagPath.node, result)
     taggedTemplateIgnoreCache.set(tagPath.node, result)
     return result

packages/weapp-tailwindcss/test/js/taggedTemplateIgnore.test.ts

@@ -45,21 +45,24 @@ describe('taggedTemplateIgnore', () => {
     expect(helper.shouldIgnore(chainedAlias)).toBe(true)
   })
 
-  it('does not treat plain String.raw aliases as ignored', () => {
+  it('does not treat plain String.raw aliases as ignored and clears cycle tracking between evaluations', () => {
     const helper = createTaggedTemplateIgnore({ matcher: () => false, names: ['weappTwIgnore'] })
-    const [rawAlias, chained, cycle] = getTagPaths([
+    const [rawAlias, chained, cycle, importedAlias] = getTagPaths([
       'const rawAlias = String.raw',
       'const chained = rawAlias',
       'rawAlias`foo`',
       'chained`bar`',
       'const a = b',
       'const b = a',
       'a`cycle`',
+      'import { weappTwIgnore as imported } from "weapp-tailwindcss/escape"',
+      'imported`ok`',
     ].join('\n'))
 
     expect(helper.shouldIgnore(rawAlias)).toBe(false)
     expect(helper.shouldIgnore(chained)).toBe(false)
     expect(helper.shouldIgnore(cycle)).toBe(false)
+    expect(helper.shouldIgnore(importedAlias)).toBe(true)
   })
 
   it('recognises helper properties on objects and computed lookups', () => {
@@ -86,6 +89,21 @@ describe('taggedTemplateIgnore', () => {
     expect(helper.shouldIgnore(unsupportedTag)).toBe(false)
   })
 
+  it('reuses effective tag evaluation for wrapped non-null expressions', () => {
+    const helper = createTaggedTemplateIgnore({ matcher: () => false, names: ['weappTwIgnore'] })
+    const [wrappedTag] = getTagPaths([
+      'import { weappTwIgnore as imported } from "weapp-tailwindcss/escape"',
+      'const chained = imported',
+      'chained!`foo`',
+    ].join('\n'), ['typescript'])
+
+    const effectiveTag = helper.getEffectiveTagPath(wrappedTag)
+
+    expect(effectiveTag.isIdentifier({ name: 'chained' })).toBe(true)
+    expect(helper.shouldIgnore(wrappedTag)).toBe(true)
+    expect(helper.shouldIgnore(effectiveTag)).toBe(true)
+  })
+
   it('returns false when identifiers are not recognised', () => {
     const helper = createTaggedTemplateIgnore({ matcher: () => false })
     const [unknownTag] = getTagPaths('unknown`foo`')