From 6fd13d6c0bcc26ce3b5598b756b585c6bf3d5fc7 Mon Sep 17 00:00:00 2001
From: Godfrey Chan <godfreykfc@gmail.com>
Date: Thu, 29 Feb 2024 20:48:00 -0800
Subject: [PATCH] Refactor import insertion code into its own module

Ultimately the goal is to fix #71 (which this commit does *not* do)

While working on that I decided to refactor the existing import
related code and add some commentary to help others understand how
it works. This just moves code around without changing behavior.
---
 Cargo.lock                           |   2 +-
 Cargo.toml                           |   2 +-
 package-lock.json                    |   4 +-
 src/importer.rs                      | 281 +++++++++++++++++++++++++++
 src/lib.rs                           | 161 +++------------
 src/{transform.rs => transformer.rs} | 115 +++++------
 6 files changed, 375 insertions(+), 190 deletions(-)
 create mode 100644 src/importer.rs
 rename src/{transform.rs => transformer.rs} (75%)

diff --git a/Cargo.lock b/Cargo.lock
index a8abab4..5c93903 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -292,7 +292,7 @@ dependencies = [
  "swc_ecma_ast",
  "swc_ecma_codegen",
  "swc_ecma_parser",
- "swc_ecma_transforms",
+ "swc_ecma_transforms_base",
  "swc_ecma_utils",
  "swc_ecma_visit",
  "swc_error_reporters",
diff --git a/Cargo.toml b/Cargo.toml
index 55f57e1..0c93841 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ swc_ecma_codegen = { git = "https://github.com/ef4/swc.git", branch = "content-t
 swc_ecma_ast = { git = "https://github.com/ef4/swc.git", branch = "content-tag" }
 swc_ecma_visit = { git = "https://github.com/ef4/swc.git", branch = "content-tag" }
 swc_ecma_utils = { git = "https://github.com/ef4/swc.git", branch = "content-tag" }
-swc_ecma_transforms = { git = "https://github.com/ef4/swc.git", branch = "content-tag" }
+swc_ecma_transforms_base = { git = "https://github.com/ef4/swc.git", branch = "content-tag" }
 swc_error_reporters = { git = "https://github.com/ef4/swc.git", branch = "content-tag" }
 lazy_static = "1.4.0"
 base64 = "0.21.4"
diff --git a/package-lock.json b/package-lock.json
index ee67ef5..4d6c947 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "content-tag",
-  "version": "1.2.2",
+  "version": "2.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "content-tag",
-      "version": "1.2.2",
+      "version": "2.0.1",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/src/importer.rs b/src/importer.rs
new file mode 100644
index 0000000..210f5c7
--- /dev/null
+++ b/src/importer.rs
@@ -0,0 +1,281 @@
+use swc_common::Mark;
+use swc_ecma_ast::{
+    Ident, ImportDecl, ImportNamedSpecifier, ImportSpecifier, Module, ModuleDecl, ModuleExportName,
+    ModuleItem,
+};
+use swc_ecma_transforms_base::{
+    hygiene::{hygiene_with_config, Config},
+    resolver,
+};
+use swc_ecma_utils::private_ident;
+use swc_ecma_visit::{Fold, VisitMut, VisitMutWith};
+
+/// Logic for managing the insertion of the following import statement:
+///
+/// ```js
+/// import { template } from "@ember/template";
+/// ```
+///
+/// * We only want to insert this if there are any `<template>` tags in the
+///   source file.
+/// * If this is already imported in the source file for some reason, we want
+///   to reuse it instead of duplicating it.
+/// * We may have to pick a unique name (`import { template as X }`), such that
+///   X can be successfully referenced from all the locations where there is a
+///   `<template>` tag. For example, the naive `template` name won't work here:
+///
+///   ```gjs
+///   function foo(template, ...args) {
+///     return <template>...</template>;
+///   }
+///   ```
+///
+///   This is a fairly trivial case, but the naming collision ("shadowing") can
+///   occur anywhere along the scope chain. Alternatively, the top-level scope
+///   may also already have another unrelated import/variable named `template`.
+pub struct Importer {
+    top_level_mark: Mark,
+    target_module: &'static str,
+    target_specifier: &'static str,
+    id: Ident,
+    need_insert: bool,
+}
+
+impl Importer {
+    pub fn prepare(
+        parsed_module: &mut Module,
+        target_module: &'static str,
+        target_specifier: &'static str,
+    ) -> Self {
+        // First, we need to prepare the AST by attaching "SyntaxContext" to
+        // identifiers, basically adding scope information to help uniquely
+        // distinguish variables that otherwise have the same names, i.e.
+        // differentiating "shadowed" variables.
+        //
+        // According to the  documentation, the resolver expects a "clean" AST
+        // where none of the identifiers already have a pre-existing syntax
+        // context attached to them, so we need to run this immediately after
+        // parsing before we insert our own private identifier for the import.
+        let unresolved_mark = Mark::new();
+        let top_level_mark = Mark::new();
+        parsed_module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
+
+        // Look for an existing import statement for the target module and
+        // specifier, possibly aliased into a different local name. If found,
+        // we can reuse its identifier, otherwise, make a new "private"
+        // identifier for it, which is an identifier with the desired name but
+        // attached to a unique "SyntaxContext".
+        let (id, need_insert) =
+            match find_existing_import(&parsed_module, target_module, target_specifier) {
+                Some(id) => (id, false),
+                None => (private_ident!(target_specifier), true),
+            };
+
+        Self {
+            top_level_mark,
+            target_module,
+            target_specifier,
+            id,
+            need_insert,
+        }
+    }
+
+    pub fn id(&self) -> &Ident {
+        &self.id
+    }
+
+    //     let mut r = renamer(swc_ecma_transforms::hygiene::Config {
+    //         keep_class_names: true,
+    //         top_level_mark,
+    //         safari_10: false,
+    //         ignore_eval: false,
+    //     });
+    //     parsed_module.visit_mut_with(&mut h);
+
+    //     simplify_imports(&mut parsed_module);
+    // }
+    pub fn insert(self, parsed_module: &mut Module) {
+        // First, insert the import statement, if needed:
+        //
+        // ```js
+        // import { $target_specifier as $ID } from $target_module;
+        // ```
+        if self.need_insert {
+            insert_import(
+                parsed_module,
+                self.target_module,
+                self.target_specifier,
+                &self.id,
+            );
+        }
+
+        // Earlier, we may have made a unique SWC identifier for the import, or
+        // we may have reused the same identifier from an existing import.
+        //
+        // Either way, because we ran the "resolver" step, all the identifiers
+        // have a "SyntaxContext" attached to it and are unique. SWC uniquely
+        // identify each identifier by both their JavaScript name AND also the
+        // "SyntaxContext" they came from.
+        //
+        // This allows our transformer to use that identifier in arbitrarily
+        // deeply nested code and SWC will still refer to the top-level import
+        // regardless of whether it is "shadowed" by a local scope higher up.
+        //
+        // You can think of this as internally representing each variable like
+        // so:
+        //
+        // ```js
+        // let foo;
+        //
+        // function bar(foo) {
+        //   console.log(foo);
+        // }
+        //
+        // console.log(foo);
+        // ```
+        //
+        // Becomes:
+        //
+        // ```js
+        // let foo__top_level;
+        //
+        // function bar(foo__function_bar) {
+        //   console.log(foo__function_bar);
+        // }
+        //
+        // console.log(foo__top_level);
+        // ```
+        //
+        // However, this system only work within SWC. "SyntaxContext" is just
+        // an internal extension in the AST and not actually reflected in the
+        // JavaScript names in any way. We are about to write things back out
+        // as normal JavaScript code, so this won't help us.
+        //
+        // In SWC, you are expect to run a "hygiene" rename pass that go find
+        // these kind of name collisions and actually rename the JS identifier
+        // names.
+        //
+        // Specifically, the first^ occurrence of a variable name gets to keep
+        // its name intact, any any subsequent variables with the same name
+        // (potentially "shadowing" an outer variable) gets renamed as
+        // `${name}${n++}`, like so:
+        //
+        // ```js
+        // let foo;
+        //
+        // function bar(foo1) {
+        //   console.log(foo1);
+        // }
+        //
+        // console.log(foo);
+        // ```
+        //
+        // ^ "first" doesn't imply any particular traversal order, so don't
+        // go assuming that the top-level name will be the bare identifier,
+        // in fact, it often isn't.
+        let mut renamer = import_renamer(self.top_level_mark);
+        parsed_module.visit_mut_with(&mut renamer);
+
+        // Finally, we know what local name is being used for our import. If it
+        // turns out that we didn't have to rename it (which is probably most
+        // of the time), then we can rename the `import { foo as foo }` to just
+        // `import { foo }`.
+        simplify_imports(parsed_module);
+    }
+}
+
+fn find_existing_import(
+    parsed_module: &Module,
+    target_module: &str,
+    target_specifier: &str,
+) -> Option<Ident> {
+    for item in parsed_module.body.iter() {
+        match item {
+            ModuleItem::ModuleDecl(ModuleDecl::Import(import_declaration)) => {
+                if import_declaration.src.value.to_string() == target_module {
+                    for specifier in import_declaration.specifiers.iter() {
+                        match specifier {
+                            ImportSpecifier::Named(s) => {
+                                let imported = match &s.imported {
+                                    Some(ModuleExportName::Ident(i)) => i.sym.to_string(),
+                                    Some(ModuleExportName::Str(s)) => s.value.to_string(),
+                                    None => s.local.sym.to_string(),
+                                };
+                                if imported == target_specifier {
+                                    return Some(s.local.clone());
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+fn insert_import(
+    parsed_module: &mut Module,
+    target_module: &str,
+    target_specifier: &str,
+    local: &Ident,
+) {
+    parsed_module.body.insert(
+        0,
+        ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
+            span: Default::default(),
+            specifiers: vec![ImportSpecifier::Named(ImportNamedSpecifier {
+                span: Default::default(),
+                local: local.clone(),
+                imported: Some(ModuleExportName::Ident(Ident::new(
+                    target_specifier.into(),
+                    Default::default(),
+                ))),
+                is_type_only: false,
+            })],
+            src: Box::new(target_module.into()),
+            type_only: false,
+            with: None,
+        })),
+    );
+}
+
+fn simplify_imports(parsed_module: &mut Module) {
+    for item in parsed_module.body.iter_mut() {
+        match item {
+            ModuleItem::ModuleDecl(ModuleDecl::Import(import_declaration)) => {
+                for specifier in import_declaration.specifiers.iter_mut() {
+                    match specifier {
+                        ImportSpecifier::Named(specifier) => {
+                            if let ImportNamedSpecifier {
+                                imported: Some(ModuleExportName::Ident(imported)),
+                                local,
+                                ..
+                            } = specifier
+                            {
+                                if local.sym == imported.sym {
+                                    specifier.imported = None;
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+// Based on swc_ecma_transforms_base::hygiene
+
+fn import_renamer(top_level_mark: Mark) -> impl 'static + Fold + VisitMut {
+    hygiene_with_config(Config {
+        keep_class_names: true,
+        top_level_mark,
+        safari_10: false,
+        ignore_eval: false,
+    })
+}
diff --git a/src/lib.rs b/src/lib.rs
index 295b09e..f54601f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,23 +7,21 @@ use base64::{engine::general_purpose, Engine as _};
 use std::path::PathBuf;
 use swc_common::comments::SingleThreadedComments;
 use swc_common::source_map::SourceMapGenConfig;
-use swc_common::{self, sync::Lrc, FileName, SourceMap, Mark};
+use swc_common::{self, sync::Lrc, FileName, SourceMap};
 use swc_core::common::GLOBALS;
-use swc_ecma_ast::{
-    Ident, ImportDecl, ImportNamedSpecifier, ImportSpecifier, Module, ModuleDecl,
-    ModuleExportName, ModuleItem,
-};
+use swc_ecma_ast::Module;
 use swc_ecma_codegen::Emitter;
 use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax, TsConfig};
-use swc_ecma_transforms::hygiene::hygiene_with_config;
-use swc_ecma_transforms::resolver;
-use swc_ecma_utils::private_ident;
-use swc_ecma_visit::{as_folder, VisitMutWith, VisitWith};
+use swc_ecma_visit::VisitWith;
 
 mod bindings;
-mod snippets;
-mod transform;
+mod importer;
 mod locate;
+mod snippets;
+mod transformer;
+
+use importer::Importer;
+use transformer::Transformer;
 
 #[derive(Default)]
 pub struct Options {
@@ -47,7 +45,6 @@ impl SourceMapGenConfig for SourceMapConfig {
     }
 }
 
-
 impl Preprocessor {
     pub fn new() -> Self {
         Self {
@@ -116,34 +113,30 @@ impl Preprocessor {
         GLOBALS.set(&Default::default(), || {
             let mut parsed_module = parser.parse_module()?;
 
-            let found_id = find_existing_import(&parsed_module, target_module, target_specifier);
-            let had_id_already = found_id.is_some();
-            let id = found_id.unwrap_or_else(|| private_ident!(target_specifier));
-            let mut needs_import = false;
-            parsed_module.visit_mut_with(&mut as_folder(transform::TransformVisitor::new(
-                &id,
-                Some(&mut needs_import),
-            )));
-
-            if !had_id_already && needs_import {
-                insert_import(&mut parsed_module, target_module, target_specifier, &id)
+            // Prepare to insert the import statement later if needed. This
+            // expects a "clean" AST so needs to be run right after parsing.
+            //
+            // This step also gives us the identifier to use in the transform.
+            // Typically, it'd be `template(...)`, but if the existing code
+            // already imported the function under a different name, we'll
+            // stick with it.
+            let import = Importer::prepare(&mut parsed_module, target_module, target_specifier);
+
+            // Run the actual code that transforms the `<template>` syntax into
+            // `template(...)`.
+            let mut transformer = Transformer::new(import.id());
+            transformer.transform(&mut parsed_module);
+
+            // If the transform didn't find any occurrences, then we did not do
+            // anything, and do not need to do anything else. (Do we even need
+            // source map in that case?)
+            if transformer.has_template_tags {
+                // If we did find `<template>` tags, we will need to insert the
+                // import statement for it, unless the existing code already
+                // have it imported for some reason
+                import.insert(&mut parsed_module);
             }
 
-            let unresolved_mark = Mark::new();
-            let top_level_mark = Mark::new();
-
-            parsed_module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
-
-            let mut h = hygiene_with_config(swc_ecma_transforms::hygiene::Config {
-                keep_class_names: true,
-                top_level_mark,
-                safari_10: false,
-                ignore_eval: false,
-            });
-            parsed_module.visit_mut_with(&mut h);
-
-            simplify_imports(&mut parsed_module);
-
             Ok(self.print(&parsed_module, options.inline_source_map))
         })
     }
@@ -192,101 +185,9 @@ impl Preprocessor {
     }
 }
 
-fn find_existing_import(
-    parsed_module: &Module,
-    target_module: &str,
-    target_specifier: &str,
-) -> Option<Ident> {
-    for item in parsed_module.body.iter() {
-        match item {
-            ModuleItem::ModuleDecl(ModuleDecl::Import(import_declaration)) => {
-                if import_declaration.src.value.to_string() == target_module {
-                    for specifier in import_declaration.specifiers.iter() {
-                        match specifier {
-                            ImportSpecifier::Named(s) => {
-                                let imported = match &s.imported {
-                                    Some(ModuleExportName::Ident(i)) => i.sym.to_string(),
-                                    Some(ModuleExportName::Str(s)) => s.value.to_string(),
-                                    None => s.local.sym.to_string(),
-                                };
-                                if imported == target_specifier {
-                                    return Some(s.local.clone());
-                                }
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-    None
-}
-
-fn insert_import(
-    parsed_module: &mut Module,
-    target_module: &str,
-    target_specifier: &str,
-    local: &Ident,
-) {
-    parsed_module.body.insert(
-        0,
-        ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
-            span: Default::default(),
-            specifiers: vec![ImportSpecifier::Named(ImportNamedSpecifier {
-                span: Default::default(),
-                local: local.clone(),
-                imported: Some(ModuleExportName::Ident(Ident::new(
-                    target_specifier.into(),
-                    Default::default(),
-                ))),
-                is_type_only: false,
-            })],
-            src: Box::new(target_module.into()),
-            type_only: false,
-            with: None,
-        })),
-    );
-}
-
-// It's not until after the hygiene pass that we know what local name is being
-// used for our import. If it turns out to equal the imported name, we can
-// implify from "import { template as template } from..." down to  "import {
-// template } from ...".
-fn simplify_imports(parsed_module: &mut Module) {
-    for item in parsed_module.body.iter_mut() {
-        match item {
-            ModuleItem::ModuleDecl(ModuleDecl::Import(import_declaration)) => {
-                for specifier in import_declaration.specifiers.iter_mut() {
-                    match specifier {
-                        ImportSpecifier::Named(specifier) => {
-                            if let ImportNamedSpecifier {
-                                imported: Some(ModuleExportName::Ident(imported)),
-                                local,
-                                ..
-                            } = specifier
-                            {
-                                if local.sym == imported.sym {
-                                    specifier.imported = None;
-                                }
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-}
-
-
-
 #[cfg(test)]
 mod test_helpers;
 
-
 macro_rules! testcase {
     ($test_name:ident, $input:expr, $expected:expr) => {
         #[test]
diff --git a/src/transform.rs b/src/transformer.rs
similarity index 75%
rename from src/transform.rs
rename to src/transformer.rs
index 322d13e..0d63677 100644
--- a/src/transform.rs
+++ b/src/transformer.rs
@@ -9,29 +9,31 @@ use swc_core::ecma::{
 };
 
 use swc_ecma_ast::{
-    ContentTagContent, ExportDefaultExpr, ExprOrSpread, ModuleDecl, ModuleItem, Tpl, TplElement,
+    ContentTagContent, ExportDefaultExpr, ExprOrSpread, Module, ModuleDecl, ModuleItem, Tpl,
+    TplElement,
 };
 
+use swc_ecma_visit::as_folder;
+
 use swc_atoms::Atom;
 
-pub struct TransformVisitor<'a> {
+pub struct Transformer {
     template_identifier: Ident,
-    found_it: Option<&'a mut bool>,
+    pub has_template_tags: bool,
 }
 
-impl<'a> TransformVisitor<'a> {
-    pub fn new(id: &Ident, found_it: Option<&'a mut bool>) -> Self {
-        TransformVisitor {
+impl Transformer {
+    pub fn new(id: &Ident) -> Self {
+        Transformer {
             template_identifier: id.clone(),
-            found_it,
+            has_template_tags: false,
         }
     }
-    fn set_found_it(&mut self) {
-        match self.found_it.as_mut() {
-            Some(flag) => **flag = true,
-            None => {}
-        }
+
+    pub fn transform(&mut self, parsed_module: &mut Module) {
+        parsed_module.visit_mut_with(&mut as_folder(self));
     }
+
     fn transform_tag_expression(&mut self, expr: &ContentTagExpression) -> Expr {
         let ContentTagExpression {
             span,
@@ -67,15 +69,19 @@ impl<'a> TransformVisitor<'a> {
 }
 
 fn escape_template_literal(input: &Atom) -> Atom {
-    input.replace("\\", "\\\\").replace("`", "\\`").replace("$", "\\$").into()
+    input
+        .replace("\\", "\\\\")
+        .replace("`", "\\`")
+        .replace("$", "\\$")
+        .into()
 }
 
-impl<'a> VisitMut for TransformVisitor<'a> {
+impl VisitMut for Transformer {
     fn visit_mut_expr(&mut self, n: &mut Expr) {
         n.visit_mut_children_with(self);
         if let Expr::ContentTagExpression(expr) = n {
             *n = self.transform_tag_expression(expr);
-            self.set_found_it();
+            self.has_template_tags = true;
         }
     }
 
@@ -108,7 +114,7 @@ impl<'a> VisitMut for TransformVisitor<'a> {
                     stmts: vec![Stmt::Expr(call_statement)],
                 },
             });
-            self.set_found_it();
+            self.has_template_tags = true;
         }
     }
 
@@ -122,7 +128,7 @@ impl<'a> VisitMut for TransformVisitor<'a> {
                         expr: Box::new(self.transform_tag_expression(&content_tag)),
                     },
                 )));
-                self.set_found_it();
+                self.has_template_tags = true;
             } else {
                 items_updated.push(item);
             }
@@ -145,16 +151,13 @@ fn content_tag_expression_statement(item: &ModuleItem) -> Option<&ContentTagExpr
     }
 }
 
-#[cfg(test)]
-use swc_core::ecma::visit::as_folder;
-
 test!(
     Default::default(),
     |_| {
-        as_folder(TransformVisitor::new(
-            &Ident::new("template".into(), Default::default()),
-            None,
-        ))
+        as_folder(Transformer::new(&Ident::new(
+            "template".into(),
+            Default::default(),
+        )))
     },
     content_tag_template_expression,
     r#"let x = <template>Hello</template>"#,
@@ -163,10 +166,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     content_tag_template_member,
     r#"class X { <template>Hello</template> } "#,
     r#"class X {
@@ -178,10 +181,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     expression_inside_class_member,
     r#"class X { thing = <template>Hello</template> } "#,
     r#"class X {
@@ -191,10 +194,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     class_member_inside_expression,
     r#"let x = class { <template>Hello</template> } "#,
     r#"let x = class {
@@ -206,10 +209,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     content_tag_export_default,
     r#"<template>Hello</template>"#,
     r#"export default template(`Hello`, { eval() { return eval(arguments[0]) }},);"#
@@ -217,10 +220,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     inner_expression,
     r#"let x = doIt(<template>Hello</template>)"#,
     r#"let x = doIt(template(`Hello`, { eval() { return eval(arguments[0]) }}))"#
@@ -228,10 +231,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     backtick_in_template,
     r#"let x = <template>He`llo</template>"#,
     r#"let x = template(`He\`llo`, { eval() { return eval(arguments[0]) }})"#
@@ -239,10 +242,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     dollar_in_template,
     r#"let x = <template>He${ll}o</template>"#,
     r#"let x = template(`He\${ll}o`, { eval() { return eval(arguments[0]) }})"#
@@ -250,10 +253,10 @@ test!(
 
 test!(
     Default::default(),
-    |_| as_folder(TransformVisitor::new(
-        &Ident::new("template".into(), Default::default()),
-        None,
-    )),
+    |_| as_folder(Transformer::new(&Ident::new(
+        "template".into(),
+        Default::default()
+    ))),
     do_not_interpret_js_escapes_in_hbs,
     r#"let x = <template>Hello\nWorld\u1234</template>"#,
     r#"let x = template(`Hello\\nWorld\\u1234`, { eval() { return eval(arguments[0]) }})"#