refactor(ast_visit): descriptive method param names in Utf8ToUtf16Converter (#10987)

overlookmotel · overlookmotel · commit 287b3c368f5d · 2025-05-13T00:10:49.000+01:00
Pure refactor. Rename function params to be more descriptive than `it`.
diff --git a/crates/oxc_ast_visit/src/generated/utf8_to_utf16_converter.rs b/crates/oxc_ast_visit/src/generated/utf8_to_utf16_converter.rs
@@ -1079,9 +1079,9 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {
         self.convert_offset(&mut it.span.end);
     }
 
-    fn visit_object_property(&mut self, it: &mut ObjectProperty<'a>) {
-        self.convert_offset(&mut it.span.start);
-        match (it.shorthand, &mut it.key, &mut it.value) {
+    fn visit_object_property(&mut self, prop: &mut ObjectProperty<'a>) {
+        self.convert_offset(&mut prop.span.start);
+        match (prop.shorthand, &mut prop.key, &mut prop.value) {
             (true, PropertyKey::StaticIdentifier(key), Expression::Identifier(value)) => {
                 self.visit_identifier_name(key);
                 value.span = key.span;
@@ -1091,12 +1091,12 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {
                 self.visit_expression(value);
             }
         }
-        self.convert_offset(&mut it.span.end);
+        self.convert_offset(&mut prop.span.end);
     }
 
-    fn visit_binding_property(&mut self, it: &mut BindingProperty<'a>) {
-        self.convert_offset(&mut it.span.start);
-        match (it.shorthand, &mut it.key, &mut it.value) {
+    fn visit_binding_property(&mut self, prop: &mut BindingProperty<'a>) {
+        self.convert_offset(&mut prop.span.start);
+        match (prop.shorthand, &mut prop.key, &mut prop.value) {
             (
                 true,
                 PropertyKey::StaticIdentifier(key),
@@ -1118,7 +1118,7 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {
                 self.visit_binding_pattern(value);
             }
         }
-        self.convert_offset(&mut it.span.end);
+        self.convert_offset(&mut prop.span.end);
     }
 
     fn visit_export_named_declaration(&mut self, decl: &mut ExportNamedDeclaration<'a>) {
@@ -1143,9 +1143,9 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {
         }
     }
 
-    fn visit_export_specifier(&mut self, it: &mut ExportSpecifier<'a>) {
-        self.convert_offset(&mut it.span.start);
-        match (&mut it.local, &mut it.exported) {
+    fn visit_export_specifier(&mut self, specifier: &mut ExportSpecifier<'a>) {
+        self.convert_offset(&mut specifier.span.start);
+        match (&mut specifier.local, &mut specifier.exported) {
             (
                 ModuleExportName::IdentifierReference(local),
                 ModuleExportName::IdentifierName(exported),
@@ -1171,36 +1171,36 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {
                 self.visit_module_export_name(exported);
             }
         }
-        self.convert_offset(&mut it.span.end);
+        self.convert_offset(&mut specifier.span.end);
     }
 
-    fn visit_import_specifier(&mut self, it: &mut ImportSpecifier<'a>) {
-        self.convert_offset(&mut it.span.start);
-        match &mut it.imported {
-            ModuleExportName::IdentifierName(imported) if imported.span == it.local.span => {
+    fn visit_import_specifier(&mut self, specifier: &mut ImportSpecifier<'a>) {
+        self.convert_offset(&mut specifier.span.start);
+        match &mut specifier.imported {
+            ModuleExportName::IdentifierName(imported) if imported.span == specifier.local.span => {
                 self.visit_identifier_name(imported);
-                it.local.span = imported.span;
+                specifier.local.span = imported.span;
             }
             imported => {
                 self.visit_module_export_name(imported);
-                self.visit_binding_identifier(&mut it.local);
+                self.visit_binding_identifier(&mut specifier.local);
             }
         }
-        self.convert_offset(&mut it.span.end);
+        self.convert_offset(&mut specifier.span.end);
     }
 
-    fn visit_with_clause(&mut self, it: &mut WithClause<'a>) {
-        self.visit_import_attributes(&mut it.with_entries);
+    fn visit_with_clause(&mut self, with_clause: &mut WithClause<'a>) {
+        self.visit_import_attributes(&mut with_clause.with_entries);
     }
 
-    fn visit_template_literal(&mut self, it: &mut TemplateLiteral<'a>) {
-        self.convert_offset(&mut it.span.start);
-        for (quasi, expression) in it.quasis.iter_mut().zip(&mut it.expressions) {
+    fn visit_template_literal(&mut self, lit: &mut TemplateLiteral<'a>) {
+        self.convert_offset(&mut lit.span.start);
+        for (quasi, expression) in lit.quasis.iter_mut().zip(&mut lit.expressions) {
             self.visit_template_element(quasi);
             self.visit_expression(expression);
         }
-        self.visit_template_element(it.quasis.last_mut().unwrap());
-        self.convert_offset(&mut it.span.end);
+        self.visit_template_element(lit.quasis.last_mut().unwrap());
+        self.convert_offset(&mut lit.span.end);
     }
 }
 
diff --git a/tasks/ast_tools/src/generators/utf8_to_utf16.rs b/tasks/ast_tools/src/generators/utf8_to_utf16.rs
@@ -96,11 +96,11 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {
             #(#methods)*
 
             ///@@line_break
-            fn visit_object_property(&mut self, it: &mut ObjectProperty<'a>) {
-                self.convert_offset(&mut it.span.start);
+            fn visit_object_property(&mut self, prop: &mut ObjectProperty<'a>) {
+                self.convert_offset(&mut prop.span.start);
 
                 // If shorthand, span of `key` and `value` are the same
-                match (it.shorthand, &mut it.key, &mut it.value) {
+                match (prop.shorthand, &mut prop.key, &mut prop.value) {
                     (true, PropertyKey::StaticIdentifier(key), Expression::Identifier(value)) => {
                         self.visit_identifier_name(key);
                         value.span = key.span;
@@ -111,15 +111,15 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {
                     }
                 }
 
-                self.convert_offset(&mut it.span.end);
+                self.convert_offset(&mut prop.span.end);
             }
 
             ///@@line_break
-            fn visit_binding_property(&mut self, it: &mut BindingProperty<'a>) {
-                self.convert_offset(&mut it.span.start);
+            fn visit_binding_property(&mut self, prop: &mut BindingProperty<'a>) {
+                self.convert_offset(&mut prop.span.start);
 
                 // If shorthand, span of `key` and `value` are the same
-                match (it.shorthand, &mut it.key, &mut it.value) {
+                match (prop.shorthand, &mut prop.key, &mut prop.value) {
                     (
                         true,
                         PropertyKey::StaticIdentifier(key),
@@ -142,7 +142,7 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {
                     }
                 }
 
-                self.convert_offset(&mut it.span.end);
+                self.convert_offset(&mut prop.span.end);
             }
 
             ///@@line_break
@@ -170,14 +170,14 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {
             }
 
             ///@@line_break
-            fn visit_export_specifier(&mut self, it: &mut ExportSpecifier<'a>) {
-                self.convert_offset(&mut it.span.start);
+            fn visit_export_specifier(&mut self, specifier: &mut ExportSpecifier<'a>) {
+                self.convert_offset(&mut specifier.span.start);
 
                 // `local` and `exported` have same span if e.g.:
                 // * `export {x}`
                 // * `export {x} from 'foo.js;`
                 // * `export {"a-b"} from 'foo.js';`
-                match (&mut it.local, &mut it.exported) {
+                match (&mut specifier.local, &mut specifier.exported) {
                     (
                         ModuleExportName::IdentifierReference(local),
                         ModuleExportName::IdentifierName(exported),
@@ -205,48 +205,48 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {
                     }
                 }
 
-                self.convert_offset(&mut it.span.end);
+                self.convert_offset(&mut specifier.span.end);
             }
 
             ///@@line_break
-            fn visit_import_specifier(&mut self, it: &mut ImportSpecifier<'a>) {
-                self.convert_offset(&mut it.span.start);
+            fn visit_import_specifier(&mut self, specifier: &mut ImportSpecifier<'a>) {
+                self.convert_offset(&mut specifier.span.start);
 
                 // `imported` and `local` have same span if e.g. `import {x} from 'foo';`
-                match &mut it.imported {
-                    ModuleExportName::IdentifierName(imported) if imported.span == it.local.span => {
+                match &mut specifier.imported {
+                    ModuleExportName::IdentifierName(imported) if imported.span == specifier.local.span => {
                         self.visit_identifier_name(imported);
-                        it.local.span = imported.span;
+                        specifier.local.span = imported.span;
                     }
                     imported => {
                         self.visit_module_export_name(imported);
-                        self.visit_binding_identifier(&mut it.local);
+                        self.visit_binding_identifier(&mut specifier.local);
                     }
                 }
 
-                self.convert_offset(&mut it.span.end);
+                self.convert_offset(&mut specifier.span.end);
             }
 
             ///@@line_break
-            fn visit_with_clause(&mut self, it: &mut WithClause<'a>) {
+            fn visit_with_clause(&mut self, with_clause: &mut WithClause<'a>) {
                 // `WithClause::attributes_keyword` has a span before start of the `WithClause`.
                 // ESTree does not include that node, nor the span of the `WithClause` itself,
                 // so skip processing those spans.
-                self.visit_import_attributes(&mut it.with_entries);
+                self.visit_import_attributes(&mut with_clause.with_entries);
             }
 
             ///@@line_break
-            fn visit_template_literal(&mut self, it: &mut TemplateLiteral<'a>) {
-                self.convert_offset(&mut it.span.start);
+            fn visit_template_literal(&mut self, lit: &mut TemplateLiteral<'a>) {
+                self.convert_offset(&mut lit.span.start);
 
                 // Visit `quasis` and `expressions` in source order. The two `Vec`s are interleaved.
-                for (quasi, expression) in it.quasis.iter_mut().zip(&mut it.expressions) {
+                for (quasi, expression) in lit.quasis.iter_mut().zip(&mut lit.expressions) {
                     self.visit_template_element(quasi);
                     self.visit_expression(expression);
                 }
-                self.visit_template_element(it.quasis.last_mut().unwrap());
+                self.visit_template_element(lit.quasis.last_mut().unwrap());
 
-                self.convert_offset(&mut it.span.end);
+                self.convert_offset(&mut lit.span.end);
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1079,9 +1079,9 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {`
`1079`	`1079`	`self.convert_offset(&mut it.span.end);`
`1080`	`1080`	`}`
`1081`	`1081`
`1082`		`- fn visit_object_property(&mut self, it: &mut ObjectProperty<'a>) {`
`1083`		`- self.convert_offset(&mut it.span.start);`
`1084`		`- match (it.shorthand, &mut it.key, &mut it.value) {`
	`1082`	`+ fn visit_object_property(&mut self, prop: &mut ObjectProperty<'a>) {`
	`1083`	`+ self.convert_offset(&mut prop.span.start);`
	`1084`	`+ match (prop.shorthand, &mut prop.key, &mut prop.value) {`
`1085`	`1085`	`(true, PropertyKey::StaticIdentifier(key), Expression::Identifier(value)) => {`
`1086`	`1086`	`self.visit_identifier_name(key);`
`1087`	`1087`	`value.span = key.span;`
`@@ -1091,12 +1091,12 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {`
`1091`	`1091`	`self.visit_expression(value);`
`1092`	`1092`	`}`
`1093`	`1093`	`}`
`1094`		`- self.convert_offset(&mut it.span.end);`
	`1094`	`+ self.convert_offset(&mut prop.span.end);`
`1095`	`1095`	`}`
`1096`	`1096`
`1097`		`- fn visit_binding_property(&mut self, it: &mut BindingProperty<'a>) {`
`1098`		`- self.convert_offset(&mut it.span.start);`
`1099`		`- match (it.shorthand, &mut it.key, &mut it.value) {`
	`1097`	`+ fn visit_binding_property(&mut self, prop: &mut BindingProperty<'a>) {`
	`1098`	`+ self.convert_offset(&mut prop.span.start);`
	`1099`	`+ match (prop.shorthand, &mut prop.key, &mut prop.value) {`
`1100`	`1100`	`(`
`1101`	`1101`	`true,`
`1102`	`1102`	`PropertyKey::StaticIdentifier(key),`
`@@ -1118,7 +1118,7 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {`
`1118`	`1118`	`self.visit_binding_pattern(value);`
`1119`	`1119`	`}`
`1120`	`1120`	`}`
`1121`		`- self.convert_offset(&mut it.span.end);`
	`1121`	`+ self.convert_offset(&mut prop.span.end);`
`1122`	`1122`	`}`
`1123`	`1123`
`1124`	`1124`	`fn visit_export_named_declaration(&mut self, decl: &mut ExportNamedDeclaration<'a>) {`
`@@ -1143,9 +1143,9 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {`
`1143`	`1143`	`}`
`1144`	`1144`	`}`
`1145`	`1145`
`1146`		`- fn visit_export_specifier(&mut self, it: &mut ExportSpecifier<'a>) {`
`1147`		`- self.convert_offset(&mut it.span.start);`
`1148`		`- match (&mut it.local, &mut it.exported) {`
	`1146`	`+ fn visit_export_specifier(&mut self, specifier: &mut ExportSpecifier<'a>) {`
	`1147`	`+ self.convert_offset(&mut specifier.span.start);`
	`1148`	`+ match (&mut specifier.local, &mut specifier.exported) {`
`1149`	`1149`	`(`
`1150`	`1150`	`ModuleExportName::IdentifierReference(local),`
`1151`	`1151`	`ModuleExportName::IdentifierName(exported),`
`@@ -1171,36 +1171,36 @@ impl<'a> VisitMut<'a> for Utf8ToUtf16Converter<'_> {`
`1171`	`1171`	`self.visit_module_export_name(exported);`
`1172`	`1172`	`}`
`1173`	`1173`	`}`
`1174`		`- self.convert_offset(&mut it.span.end);`
	`1174`	`+ self.convert_offset(&mut specifier.span.end);`
`1175`	`1175`	`}`
`1176`	`1176`
`1177`		`- fn visit_import_specifier(&mut self, it: &mut ImportSpecifier<'a>) {`
`1178`		`- self.convert_offset(&mut it.span.start);`
`1179`		`- match &mut it.imported {`
`1180`		`- ModuleExportName::IdentifierName(imported) if imported.span == it.local.span => {`
	`1177`	`+ fn visit_import_specifier(&mut self, specifier: &mut ImportSpecifier<'a>) {`
	`1178`	`+ self.convert_offset(&mut specifier.span.start);`
	`1179`	`+ match &mut specifier.imported {`
	`1180`	`+ ModuleExportName::IdentifierName(imported) if imported.span == specifier.local.span => {`
`1181`	`1181`	`self.visit_identifier_name(imported);`
`1182`		`- it.local.span = imported.span;`
	`1182`	`+ specifier.local.span = imported.span;`
`1183`	`1183`	`}`
`1184`	`1184`	`imported => {`
`1185`	`1185`	`self.visit_module_export_name(imported);`
`1186`		`- self.visit_binding_identifier(&mut it.local);`
	`1186`	`+ self.visit_binding_identifier(&mut specifier.local);`
`1187`	`1187`	`}`
`1188`	`1188`	`}`
`1189`		`- self.convert_offset(&mut it.span.end);`
	`1189`	`+ self.convert_offset(&mut specifier.span.end);`
`1190`	`1190`	`}`
`1191`	`1191`
`1192`		`- fn visit_with_clause(&mut self, it: &mut WithClause<'a>) {`
`1193`		`- self.visit_import_attributes(&mut it.with_entries);`
	`1192`	`+ fn visit_with_clause(&mut self, with_clause: &mut WithClause<'a>) {`
	`1193`	`+ self.visit_import_attributes(&mut with_clause.with_entries);`
`1194`	`1194`	`}`
`1195`	`1195`
`1196`		`- fn visit_template_literal(&mut self, it: &mut TemplateLiteral<'a>) {`
`1197`		`- self.convert_offset(&mut it.span.start);`
`1198`		`- for (quasi, expression) in it.quasis.iter_mut().zip(&mut it.expressions) {`
	`1196`	`+ fn visit_template_literal(&mut self, lit: &mut TemplateLiteral<'a>) {`
	`1197`	`+ self.convert_offset(&mut lit.span.start);`
	`1198`	`+ for (quasi, expression) in lit.quasis.iter_mut().zip(&mut lit.expressions) {`
`1199`	`1199`	`self.visit_template_element(quasi);`
`1200`	`1200`	`self.visit_expression(expression);`
`1201`	`1201`	`}`
`1202`		`- self.visit_template_element(it.quasis.last_mut().unwrap());`
`1203`		`- self.convert_offset(&mut it.span.end);`
	`1202`	`+ self.visit_template_element(lit.quasis.last_mut().unwrap());`
	`1203`	`+ self.convert_offset(&mut lit.span.end);`
`1204`	`1204`	`}`
`1205`	`1205`	`}`
`1206`	`1206`
Original file line number	Diff line number	Diff line change
`@@ -96,11 +96,11 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {`
`96`	`96`	`#(#methods)*`
`97`	`97`
`98`	`98`	`///@@line_break`
`99`		`- fn visit_object_property(&mut self, it: &mut ObjectProperty<'a>) {`
`100`		`- self.convert_offset(&mut it.span.start);`
	`99`	`+ fn visit_object_property(&mut self, prop: &mut ObjectProperty<'a>) {`
	`100`	`+ self.convert_offset(&mut prop.span.start);`
`101`	`101`
`102`	`102`	// If shorthand, span of `key` and `value` are the same
`103`		`- match (it.shorthand, &mut it.key, &mut it.value) {`
	`103`	`+ match (prop.shorthand, &mut prop.key, &mut prop.value) {`
`104`	`104`	`(true, PropertyKey::StaticIdentifier(key), Expression::Identifier(value)) => {`
`105`	`105`	`self.visit_identifier_name(key);`
`106`	`106`	`value.span = key.span;`
`@@ -111,15 +111,15 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`		`- self.convert_offset(&mut it.span.end);`
	`114`	`+ self.convert_offset(&mut prop.span.end);`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`///@@line_break`
`118`		`- fn visit_binding_property(&mut self, it: &mut BindingProperty<'a>) {`
`119`		`- self.convert_offset(&mut it.span.start);`
	`118`	`+ fn visit_binding_property(&mut self, prop: &mut BindingProperty<'a>) {`
	`119`	`+ self.convert_offset(&mut prop.span.start);`
`120`	`120`
`121`	`121`	// If shorthand, span of `key` and `value` are the same
`122`		`- match (it.shorthand, &mut it.key, &mut it.value) {`
	`122`	`+ match (prop.shorthand, &mut prop.key, &mut prop.value) {`
`123`	`123`	`(`
`124`	`124`	`true,`
`125`	`125`	`PropertyKey::StaticIdentifier(key),`
`@@ -142,7 +142,7 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`		`- self.convert_offset(&mut it.span.end);`
	`145`	`+ self.convert_offset(&mut prop.span.end);`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`///@@line_break`
`@@ -170,14 +170,14 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`///@@line_break`
`173`		`- fn visit_export_specifier(&mut self, it: &mut ExportSpecifier<'a>) {`
`174`		`- self.convert_offset(&mut it.span.start);`
	`173`	`+ fn visit_export_specifier(&mut self, specifier: &mut ExportSpecifier<'a>) {`
	`174`	`+ self.convert_offset(&mut specifier.span.start);`
`175`	`175`
`176`	`176`	// `local` and `exported` have same span if e.g.:
`177`	`177`	// * `export {x}`
`178`	`178`	// * `export {x} from 'foo.js;`
`179`	`179`	// * `export {"a-b"} from 'foo.js';`
`180`		`- match (&mut it.local, &mut it.exported) {`
	`180`	`+ match (&mut specifier.local, &mut specifier.exported) {`
`181`	`181`	`(`
`182`	`182`	`ModuleExportName::IdentifierReference(local),`
`183`	`183`	`ModuleExportName::IdentifierName(exported),`
`@@ -205,48 +205,48 @@ fn generate(schema: &Schema, codegen: &Codegen) -> TokenStream {`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`
`208`		`- self.convert_offset(&mut it.span.end);`
	`208`	`+ self.convert_offset(&mut specifier.span.end);`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`///@@line_break`
`212`		`- fn visit_import_specifier(&mut self, it: &mut ImportSpecifier<'a>) {`
`213`		`- self.convert_offset(&mut it.span.start);`
	`212`	`+ fn visit_import_specifier(&mut self, specifier: &mut ImportSpecifier<'a>) {`
	`213`	`+ self.convert_offset(&mut specifier.span.start);`
`214`	`214`
`215`	`215`	// `imported` and `local` have same span if e.g. `import {x} from 'foo';`
`216`		`- match &mut it.imported {`
`217`		`- ModuleExportName::IdentifierName(imported) if imported.span == it.local.span => {`
	`216`	`+ match &mut specifier.imported {`
	`217`	`+ ModuleExportName::IdentifierName(imported) if imported.span == specifier.local.span => {`
`218`	`218`	`self.visit_identifier_name(imported);`
`219`		`- it.local.span = imported.span;`
	`219`	`+ specifier.local.span = imported.span;`
`220`	`220`	`}`
`221`	`221`	`imported => {`
`222`	`222`	`self.visit_module_export_name(imported);`
`223`		`- self.visit_binding_identifier(&mut it.local);`
	`223`	`+ self.visit_binding_identifier(&mut specifier.local);`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`
`227`		`- self.convert_offset(&mut it.span.end);`
	`227`	`+ self.convert_offset(&mut specifier.span.end);`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`///@@line_break`
`231`		`- fn visit_with_clause(&mut self, it: &mut WithClause<'a>) {`
	`231`	`+ fn visit_with_clause(&mut self, with_clause: &mut WithClause<'a>) {`
`232`	`232`	// `WithClause::attributes_keyword` has a span before start of the `WithClause`.
`233`	`233`	// ESTree does not include that node, nor the span of the `WithClause` itself,
`234`	`234`	`// so skip processing those spans.`
`235`		`- self.visit_import_attributes(&mut it.with_entries);`
	`235`	`+ self.visit_import_attributes(&mut with_clause.with_entries);`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`///@@line_break`
`239`		`- fn visit_template_literal(&mut self, it: &mut TemplateLiteral<'a>) {`
`240`		`- self.convert_offset(&mut it.span.start);`
	`239`	`+ fn visit_template_literal(&mut self, lit: &mut TemplateLiteral<'a>) {`
	`240`	`+ self.convert_offset(&mut lit.span.start);`
`241`	`241`
`242`	`242`	// Visit `quasis` and `expressions` in source order. The two `Vec`s are interleaved.
`243`		`- for (quasi, expression) in it.quasis.iter_mut().zip(&mut it.expressions) {`
	`243`	`+ for (quasi, expression) in lit.quasis.iter_mut().zip(&mut lit.expressions) {`
`244`	`244`	`self.visit_template_element(quasi);`
`245`	`245`	`self.visit_expression(expression);`
`246`	`246`	`}`
`247`		`- self.visit_template_element(it.quasis.last_mut().unwrap());`
	`247`	`+ self.visit_template_element(lit.quasis.last_mut().unwrap());`
`248`	`248`
`249`		`- self.convert_offset(&mut it.span.end);`
	`249`	`+ self.convert_offset(&mut lit.span.end);`
`250`	`250`	`}`
`251`	`251`	`}`
`252`	`252`