traverse ast to discover locals

Author: patricklx

src/plugin.ts

@@ -7,7 +7,7 @@ import { JSUtils, ExtendedPluginBuilder } from './js-utils';
 import type { EmberTemplateCompiler, PreprocessOptions } from './ember-template-compiler';
 import { LegacyModuleName } from './public-types';
 import { ScopeLocals } from './scope-locals';
-import { ASTPluginBuilder, getTemplateLocals, preprocess, print } from '@glimmer/syntax';
+import { ASTPluginBuilder, preprocess, print, traverse, WalkerPath } from '@glimmer/syntax';
 
 export * from './public-types';
 
@@ -373,31 +373,57 @@ function runtimeErrorIIFE(babel: typeof Babel, replacements: { ERROR_MESSAGE: st
 function buildScopeLocals(
   userTypedOptions: Record<string, unknown>,
   formatOptions: ModuleConfig,
-  templateContent: string
+  templateContent: string,
+  path: NodePath<t.Expression>
 ): ScopeLocals {
   if (formatOptions.rfc931Support && userTypedOptions.eval) {
-    return discoverLocals(templateContent);
+    return discoverLocals(templateContent, path);
   } else if (userTypedOptions.scope) {
     return userTypedOptions.scope as ScopeLocals;
   } else {
     return new ScopeLocals();
   }
 }
 
-function discoverLocals(templateContent: string): ScopeLocals {
-  // this is wrong, but the right thing is unreleased in
-  // https://github.com/glimmerjs/glimmer-vm/pull/1421, so for the moment I'm
-  // sticking with the exact behavior that ember-templates-imports has.
-  //
-  // (the reason it's wrong is that the correct answer depends on not just the
-  // template, but the ambient javascript scope. Anything in locals needs to win
-  // over ember keywords. Otherwise we can never introduce new keywords.)
+function discoverLocals(templateContent: string, jsPath: NodePath<t.Expression>): ScopeLocals {
   let scopeLocals = new ScopeLocals();
-  for (let local of getTemplateLocals(templateContent)) {
-    if (local.match(/^[$A-Z_][0-9A-Z_$]*$/i)) {
-      scopeLocals.add(local);
+  const ast = preprocess(templateContent);
+  function isInScope(path: WalkerPath<any>, name: string) {
+    while (path.parent) {
+      path = path.parent;
+      if (path.node.blockParams && path.node.blockParams.includes(name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function isInJsScope(name: string) {
+    if (jsPath.scope.getBinding(name)) return true;
+    if (['this', 'globalThis'].includes(name)) return true;
+    if (jsPath.state.originalImportedNames.has(name)) {
+      return true;
     }
+    return false;
   }
+
+  traverse(ast, {
+    PathExpression(node, path) {
+      if (
+        node.head.type === 'VarHead' &&
+        !isInScope(path, node.head.name) &&
+        isInJsScope(node.head.name)
+      ) {
+        scopeLocals.add(node.head.name);
+      }
+    },
+    ElementNode(node, path) {
+      const name = node.tag.split('.')[0];
+      if (!isInScope(path, name) && isInJsScope(name)) {
+        scopeLocals.add(name);
+      }
+    },
+  });
   return scopeLocals;
 }
 
@@ -483,7 +509,8 @@ function insertCompiledTemplate<EnvSpecificOptions>(
   backingClass: NodePath<Parameters<typeof t.callExpression>[1][number]> | undefined
 ) {
   let t = babel.types;
-  let scopeLocals = buildScopeLocals(userTypedOptions, config, template);
+  target.state = state;
+  let scopeLocals = buildScopeLocals(userTypedOptions, config, template, target);
   let options = buildPrecompileOptions(
     babel,
     target,
@@ -560,7 +587,8 @@ function insertTransformedTemplate<EnvSpecificOptions>(
   backingClass: NodePath<Parameters<typeof t.callExpression>[1][number]> | undefined
 ) {
   let t = babel.types;
-  let scopeLocals = buildScopeLocals(userTypedOptions, formatOptions, template);
+  target.state = state;
+  let scopeLocals = buildScopeLocals(userTypedOptions, formatOptions, template, target);
   let options = buildPrecompileOptions(
     babel,
     target,