Repository: biomejs/biome (language: rust)

Issue:
💅 incorrect`lint/style/useTemplate` on multiline template string
### Environment information

```bash
CLI:
  Version:                      1.9.4
  Color support:                true

Platform:
  CPU Architecture:             aarch64
  OS:                           macos

Environment:
  BIOME_LOG_PATH:               unset
  BIOME_LOG_PREFIX_NAME:        unset
  BIOME_CONFIG_PATH:            unset
  NO_COLOR:                     unset
  TERM:                         "xterm-256color"
  JS_RUNTIME_VERSION:           "v20.11.0"
  JS_RUNTIME_NAME:              "node"
  NODE_PACKAGE_MANAGER:         "npm/10.2.4"

Biome Configuration:
  Status:                       Loaded successfully
  Formatter disabled:           false
  Linter disabled:              false
  Organize imports disabled:    false
  VCS disabled:                 false

Linter:
  JavaScript enabled:           true
  JSON enabled:                 true
  CSS enabled:                  true
  GraphQL enabled:              false
  Recommended:                  true
  All:                          false
  Enabled rules:
  performance/noDelete
  suspicious/noCatchAssign
  suspicious/noUnsafeNegation
  complexity/useLiteralKeys
  style/useImportType
  complexity/noMultipleSpacesInRegularExpressionLiterals
  a11y/useValidLang
  complexity/noUselessEmptyExport
  suspicious/useNamespaceKeyword
  suspicious/useValidTypeof
  a11y/useValidAriaRole
  suspicious/noAssignInExpressions
  a11y/useAriaActivedescendantWithTabindex
  suspicious/noDuplicateParameters
  style/useDefaultParameterLast
  complexity/noEmptyTypeParameters
  correctness/noConstructorReturn
  suspicious/noDuplicateSelectorsKeyframeBlock
  correctness/noUnknownProperty
  style/useTemplate
  correctness/noUnusedLabels
  complexity/noUselessTernary
  correctness/noUnreachableSuper
  suspicious/noCompareNegZero
  correctness/noSwitchDeclarations
  a11y/noAutofocus
  correctness/noUnsafeOptionalChaining
  correctness/noConstAssign
  suspicious/noControlCharactersInRegex
  complexity/noUselessTypeConstraint
  style/noVar
  suspicious/noDoubleEquals
  suspicious/noRedundantUseStrict
  style/useLiteralEnumMembers
  suspicious/noGlobalIsNan
  suspicious/noEmptyInterface
  suspicious/noConstEnum
  suspicious/noMisleadingCharacterClass
  correctness/noPrecisionLoss
  a11y/noLabelWithoutControl
  suspicious/noRedeclare
  correctness/noStringCaseMismatch
  correctness/noSetterReturn
  correctness/noInvalidConstructorSuper
  suspicious/noFallthroughSwitchClause
  suspicious/noUnsafeDeclarationMerging
  correctness/noUnreachable
  a11y/useKeyWithClickEvents
  suspicious/noDuplicateObjectKeys
  complexity/noUselessThisAlias
  complexity/useOptionalChain
  correctness/noInnerDeclarations
  suspicious/noDuplicateCase
  complexity/useRegexLiterals
  correctness/noSelfAssign
  correctness/noInvalidBuiltinInstantiation
  style/noUselessElse
  style/useShorthandFunctionType
  suspicious/noShadowRestrictedNames
  correctness/noInvalidDirectionInLinearGradient
  suspicious/noImportantInKeyframe
  a11y/useMediaCaption
  complexity/noUselessLabel
  complexity/noUselessCatch
  correctness/noUnsafeFinally
  a11y/useAriaPropsForRole
  correctness/noNonoctalDecimalEscape
  style/useEnumInitializers
  a11y/useHtmlLang
  suspicious/noDuplicateTestHooks
  style/useWhile
  complexity/useArrowFunction
  style/noInferrableTypes
  a11y/noNoninteractiveTabindex
  complexity/useSimpleNumberKeys
  correctness/useYield
  a11y/noInteractiveElementToNoninteractiveRole
  style/useNumericLiterals
  correctness/noUnnecessaryContinue
  suspicious/noApproximativeNumericConstant
  suspicious/noImportAssign
  suspicious/noLabelVar
  correctness/noGlobalObjectCalls
  suspicious/useDefaultSwitchClauseLast
  a11y/useAltText
  correctness/noEmptyCharacterClassInRegex
  correctness/noUnknownUnit
  suspicious/noSparseArray
  a11y/useIframeTitle
  suspicious/noPrototypeBuiltins
  a11y/noSvgWithoutTitle
  correctness/noVoidElementsWithChildren
  style/useAsConstAssertion
  correctness/useJsxKeyInIterable
  style/useExportType
  complexity/noUselessLoneBlockStatements
  style/noArguments
  a11y/useValidAriaValues
  suspicious/noDebugger
  suspicious/noMisleadingInstantiator
  a11y/useFocusableInteractive
  suspicious/noCommentText
  correctness/noUnmatchableAnbSelector
  suspicious/noDuplicateJsxProps
  suspicious/noGlobalAssign
  a11y/noPositiveTabindex
  correctness/noEmptyPattern
  complexity/noExcessiveNestedTestSuites
  security/noDangerouslySetInnerHtmlWithChildren
  a11y/useKeyWithMouseEvents
  suspicious/noExtraNonNullAssertion
  suspicious/noShorthandPropertyOverrides
  correctness/noRenderReturnValue
  correctness/useExhaustiveDependencies
  security/noGlobalEval
  suspicious/useGetterReturn
  a11y/noRedundantRoles
  complexity/useFlatMap
  correctness/useIsNan
  suspicious/noGlobalIsFinite
  suspicious/noSelfCompare
  suspicious/noThenProperty
  suspicious/noAsyncPromiseExecutor
  suspicious/noDuplicateFontNames
  a11y/noDistractingElements
  complexity/noWith
  suspicious/noDuplicateClassMembers
  complexity/noExtraBooleanCast
  performance/noAccumulatingSpread
  a11y/useValidAriaProps
  a11y/noRedundantAlt
  correctness/noChildrenProp
  correctness/noUnknownFunction
  correctness/noInvalidPositionAtImportRule
  suspicious/noConfusingLabels
  suspicious/noConfusingVoidType
  suspicious/noFocusedTests
  a11y/useSemanticElements
  a11y/noAriaUnsupportedElements
  correctness/noInvalidGridAreas
  correctness/noFlatMapIdentity
  suspicious/noSuspiciousSemicolonInJsx
  a11y/noBlankTarget
  a11y/useHeadingContent
  correctness/useValidForDirection
  correctness/noVoidTypeReturn
  correctness/noInvalidUseBeforeDeclaration
  a11y/noAriaHiddenOnFocusable
  a11y/useGenericFontNames
  correctness/noUnknownMediaFeatureName
  a11y/useAnchorContent
  complexity/noUselessRename
  style/useNumberNamespace
  complexity/noUselessConstructor
  a11y/noAccessKey
  style/useExponentiationOperator
  complexity/noUselessSwitchCase
  style/useSingleVarDeclarator
  suspicious/noExportsInTest
  a11y/noNoninteractiveElementToInteractiveRole
  style/noCommaOperator
  suspicious/noDuplicateAtImportRules
  suspicious/useIsArray
  a11y/noHeaderScope
  complexity/noUselessFragments
  suspicious/noMisrefactoredShorthandAssign
  suspicious/noEmptyBlock
  suspicious/noClassAssign
  suspicious/noFunctionAssign

Workspace:
  Open Documents:               0
```

### Rule name

lint/style/useTemplate

### Playground link

https://biomejs.dev/playground/?code=YwBvAG4AcwB0ACAAVgBBAEwAVQBFACAAPQAgACcAdABlAHMAdAAnAAoACgBjAG8AbgBzAHQAIABzAHQAcgBpAG4AZwAgAD0AIABgACQAewBWAEEATABVAEUAfQAgAHQAZQBtAHAAbABhAHQAZQBgACAAKwAgACcAIABpAG4AdgBhAGwAaQBkACcACgA%3D

### Expected result

When template string is used, we often have to use `+` to fold multiple lines for text visibility, but `lint/style/useTemplate` doesn't accept that even though the template is actually used.

```ts
const VALUE = 'test'

// biome-ignore lint/style/useTemplate: <explanation>
const string = `${VALUE} template` + ' invalid'
```

![Image](https://github.com/user-attachments/assets/f48a87ea-147a-40e3-94df-73945c6fe0d2)

### Code of Conduct

- [x] I agree to follow Biome's Code of Conduct


Discussion / hints:
Can you be more precise about your expectations of the rule for this use case? 

The reason why the rule is triggered  is because you use a binary expression to concatenate two strings, while the rule imposes the use of **one template** literal.
I'm not sure if I understand your ask well, but when a string literal gets really long, you'd want to break it into multiple strings so that the width is limited within the screen size.

string concat by `+` itself is allowed in JS and biome as well, however when and only when a template string is involved, biome complaints.

Here's an example that highlights the diff:

![Image](https://github.com/user-attachments/assets/ddb05d0c-7efe-4c76-ab4b-876c24a8af25)

Does that make sense?
Ok, the valid example helped a lot :)

Fix patch:
diff --git a/.changeset/orange-gifts-burn.md b/.changeset/orange-gifts-burn.md
new file mode 100644
index 000000000000..660e7e720363
--- /dev/null
+++ b/.changeset/orange-gifts-burn.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fix [#4947](https://github.com/biomejs/biome/issues/4947): the `useTemplate` lint rule now ignores concatenated literals folded to multiple lines.
diff --git a/crates/biome_js_analyze/src/lint/style/use_template.rs b/crates/biome_js_analyze/src/lint/style/use_template.rs
index a9c7e1aa85c8..031851e751e4 100644
--- a/crates/biome_js_analyze/src/lint/style/use_template.rs
+++ b/crates/biome_js_analyze/src/lint/style/use_template.rs
@@ -121,38 +121,47 @@ fn can_be_template_literal(node: &JsBinaryExpression) -> Option<bool> {
     let mut has_interpolated_string_constituent = false;
     let mut has_non_constant_string_constituent = false;
     while let Some(walk) = iter.next() {
-        if let WalkEvent::Enter(node) = walk {
-            let expression = AnyJsExpression::cast(node)?;
-            match &expression {
-                AnyJsExpression::JsParenthesizedExpression(_) => continue,
-                AnyJsExpression::JsBinaryExpression(binary)
-                    if binary.operator() == Ok(JsBinaryOperator::Plus) =>
+        let WalkEvent::Enter(node) = walk else {
+            continue;
+        };
+        let expression = AnyJsExpression::cast(node)?;
+        match &expression {
+            AnyJsExpression::JsParenthesizedExpression(_) => continue,
+            AnyJsExpression::JsBinaryExpression(binary)
+                if binary.operator() == Ok(JsBinaryOperator::Plus) =>
+            {
+                // Long literals can be split to multiline using `+`, so let's ignore that.
+                // see https://github.com/biomejs/biome/issues/4947
+                if binary.operator_token().ok()?.has_leading_newline()
+                    || binary.right().ok()?.syntax().has_leading_newline()
                 {
-                    continue
-                }
-                AnyJsExpression::JsTemplateExpression(template) if template.is_constant() => {
-                    has_constant_string_constituent = true;
-                }
-                AnyJsExpression::JsTemplateExpression(template) if template.tag().is_none() => {
-                    has_interpolated_string_constituent = true;
-                }
-                AnyJsExpression::AnyJsLiteralExpression(
-                    AnyJsLiteralExpression::JsStringLiteralExpression(_),
-                ) => {
-                    has_constant_string_constituent = true;
-                }
-                _ => {
-                    has_non_constant_string_constituent = true;
+                    return Some(false);
                 }
+
+                continue;
             }
-            if (has_constant_string_constituent
-                && (has_non_constant_string_constituent || has_interpolated_string_constituent))
-                || (has_interpolated_string_constituent && has_non_constant_string_constituent)
-            {
-                return Some(true);
+            AnyJsExpression::JsTemplateExpression(template) if template.is_constant() => {
+                has_constant_string_constituent = true;
+            }
+            AnyJsExpression::JsTemplateExpression(template) if template.tag().is_none() => {
+                has_interpolated_string_constituent = true;
+            }
+            AnyJsExpression::AnyJsLiteralExpression(
+                AnyJsLiteralExpression::JsStringLiteralExpression(_),
+            ) => {
+                has_constant_string_constituent = true;
             }
-            iter.skip_subtree();
+            _ => {
+                has_non_constant_string_constituent = true;
+            }
+        }
+        if (has_constant_string_constituent
+            && (has_non_constant_string_constituent || has_interpolated_string_constituent))
+            || (has_interpolated_string_constituent && has_non_constant_string_constituent)
+        {
+            return Some(true);
         }
+        iter.skip_subtree();
     }
     Some(false)
 }


Test patch:
diff --git a/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js b/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js
index e713646aeb24..5db93a8a159b 100644
--- a/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js
+++ b/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js
@@ -56,9 +56,6 @@ const x = a + ("b") + c;
 
 //a
 /*b*/ foo /*c*/ + /*d*/ 'baz' /*e*/ + /*f*/ 1 //g
-+ //h
-bar //i
-
 
 // parentheses and type coercion
 
diff --git a/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js.snap b/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js.snap
index 84aa00667273..7d3607e4da97 100644
--- a/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js.snap
+++ b/crates/biome_js_analyze/tests/specs/style/useTemplate/invalid.js.snap
@@ -1,7 +1,6 @@
 ---
 source: crates/biome_js_analyze/tests/spec_tests.rs
 expression: invalid.js
-snapshot_kind: text
 ---
 # Input
 ```js
@@ -63,9 +62,6 @@ const x = a + ("b") + c;
 
 //a
 /*b*/ foo /*c*/ + /*d*/ 'baz' /*e*/ + /*f*/ 1 //g
-+ //h
-bar //i
-
 
 // parentheses and type coercion
 
@@ -765,524 +761,520 @@ invalid.js:58:7 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━
   
     57 │ //a
   > 58 │ /*b*/ foo /*c*/ + /*d*/ 'baz' /*e*/ + /*f*/ 1 //g
-       │       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  > 59 │ + //h
-  > 60 │ bar //i
-       │ ^^^
-    61 │ 
+       │       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    59 │ 
+    60 │ // parentheses and type coercion
   
   i Unsafe fix: Use a template literal.
   
      56  56 │   
      57  57 │   //a
      58     │ - /*b*/·foo·/*c*/·+·/*d*/·'baz'·/*e*/·+·/*f*/·1·//g
-     59     │ - +·//h
-     60     │ - bar·//i
-         58 │ + /*b*/·`${foo}baz${1}${bar}`·//i
-     61  59 │   
-     62  60 │   
+         58 │ + /*b*/·`${foo}baz${1}`·//g
+     59  59 │   
+     60  60 │   // parentheses and type coercion
   
 
 ```
 
 ```
-invalid.js:65:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:62:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    63 │ // parentheses and type coercion
-    64 │ 
-  > 65 │ "a" + (1 + 2); // `a${1 + 2}`
+    60 │ // parentheses and type coercion
+    61 │ 
+  > 62 │ "a" + (1 + 2); // `a${1 + 2}`
        │ ^^^^^^^^^^^^^
-    66 │ 
-    67 │ (1 + 2) + "a"; // `${1 + 2}a`
+    63 │ 
+    64 │ (1 + 2) + "a"; // `${1 + 2}a`
   
   i Unsafe fix: Use a template literal.
   
-     63  63 │   // parentheses and type coercion
-     64  64 │   
-     65     │ - "a"·+·(1·+·2);·//·`a${1·+·2}`
-         65 │ + `a${1·+·2}`;·//·`a${1·+·2}`
-     66  66 │   
-     67  67 │   (1 + 2) + "a"; // `${1 + 2}a`
+     60  60 │   // parentheses and type coercion
+     61  61 │   
+     62     │ - "a"·+·(1·+·2);·//·`a${1·+·2}`
+         62 │ + `a${1·+·2}`;·//·`a${1·+·2}`
+     63  63 │   
+     64  64 │   (1 + 2) + "a"; // `${1 + 2}a`
   
 
 ```
 
 ```
-invalid.js:67:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:64:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    65 │ "a" + (1 + 2); // `a${1 + 2}`
-    66 │ 
-  > 67 │ (1 + 2) + "a"; // `${1 + 2}a`
+    62 │ "a" + (1 + 2); // `a${1 + 2}`
+    63 │ 
+  > 64 │ (1 + 2) + "a"; // `${1 + 2}a`
        │ ^^^^^^^^^^^^^
-    68 │ 
-    69 │ 1 + 2 + "a"; // `${1 + 2}a`
+    65 │ 
+    66 │ 1 + 2 + "a"; // `${1 + 2}a`
   
   i Unsafe fix: Use a template literal.
   
-     65  65 │   "a" + (1 + 2); // `a${1 + 2}`
-     66  66 │   
-     67     │ - (1·+·2)·+·"a";·//·`${1·+·2}a`
-         67 │ + `${1·+·2}a`;·//·`${1·+·2}a`
-     68  68 │   
-     69  69 │   1 + 2 + "a"; // `${1 + 2}a`
+     62  62 │   "a" + (1 + 2); // `a${1 + 2}`
+     63  63 │   
+     64     │ - (1·+·2)·+·"a";·//·`${1·+·2}a`
+         64 │ + `${1·+·2}a`;·//·`${1·+·2}a`
+     65  65 │   
+     66  66 │   1 + 2 + "a"; // `${1 + 2}a`
   
 
 ```
 
 ```
-invalid.js:69:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:66:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    67 │ (1 + 2) + "a"; // `${1 + 2}a`
-    68 │ 
-  > 69 │ 1 + 2 + "a"; // `${1 + 2}a`
+    64 │ (1 + 2) + "a"; // `${1 + 2}a`
+    65 │ 
+  > 66 │ 1 + 2 + "a"; // `${1 + 2}a`
        │ ^^^^^^^^^^^
-    70 │ 
-    71 │ (1 + 2) + ("a"); // `${1 + 2}a`
+    67 │ 
+    68 │ (1 + 2) + ("a"); // `${1 + 2}a`
   
   i Unsafe fix: Use a template literal.
   
-     67  67 │   (1 + 2) + "a"; // `${1 + 2}a`
-     68  68 │   
-     69     │ - 1·+·2·+·"a";·//·`${1·+·2}a`
-         69 │ + `${1·+·2}a`;·//·`${1·+·2}a`
-     70  70 │   
-     71  71 │   (1 + 2) + ("a"); // `${1 + 2}a`
+     64  64 │   (1 + 2) + "a"; // `${1 + 2}a`
+     65  65 │   
+     66     │ - 1·+·2·+·"a";·//·`${1·+·2}a`
+         66 │ + `${1·+·2}a`;·//·`${1·+·2}a`
+     67  67 │   
+     68  68 │   (1 + 2) + ("a"); // `${1 + 2}a`
   
 
 ```
 
 ```
-invalid.js:71:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:68:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    69 │ 1 + 2 + "a"; // `${1 + 2}a`
-    70 │ 
-  > 71 │ (1 + 2) + ("a"); // `${1 + 2}a`
+    66 │ 1 + 2 + "a"; // `${1 + 2}a`
+    67 │ 
+  > 68 │ (1 + 2) + ("a"); // `${1 + 2}a`
        │ ^^^^^^^^^^^^^^^
-    72 │ 
-    73 │ "a" + 1 + 2; // `a${1}${2}`
+    69 │ 
+    70 │ "a" + 1 + 2; // `a${1}${2}`
   
   i Unsafe fix: Use a template literal.
   
-     69  69 │   1 + 2 + "a"; // `${1 + 2}a`
-     70  70 │   
-     71     │ - (1·+·2)·+·("a");·//·`${1·+·2}a`
-         71 │ + `${1·+·2}a`;·//·`${1·+·2}a`
-     72  72 │   
-     73  73 │   "a" + 1 + 2; // `a${1}${2}`
+     66  66 │   1 + 2 + "a"; // `${1 + 2}a`
+     67  67 │   
+     68     │ - (1·+·2)·+·("a");·//·`${1·+·2}a`
+         68 │ + `${1·+·2}a`;·//·`${1·+·2}a`
+     69  69 │   
+     70  70 │   "a" + 1 + 2; // `a${1}${2}`
   
 
 ```
 
 ```
-invalid.js:73:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:70:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    71 │ (1 + 2) + ("a"); // `${1 + 2}a`
-    72 │ 
-  > 73 │ "a" + 1 + 2; // `a${1}${2}`
+    68 │ (1 + 2) + ("a"); // `${1 + 2}a`
+    69 │ 
+  > 70 │ "a" + 1 + 2; // `a${1}${2}`
        │ ^^^^^^^^^^^
-    74 │ 
-    75 │ 1 + (2 + "a"); // `${1}${2}a`
+    71 │ 
+    72 │ 1 + (2 + "a"); // `${1}${2}a`
   
   i Unsafe fix: Use a template literal.
   
-     71  71 │   (1 + 2) + ("a"); // `${1 + 2}a`
-     72  72 │   
-     73     │ - "a"·+·1·+·2;·//·`a${1}${2}`
-         73 │ + `a${1}${2}`;·//·`a${1}${2}`
-     74  74 │   
-     75  75 │   1 + (2 + "a"); // `${1}${2}a`
+     68  68 │   (1 + 2) + ("a"); // `${1 + 2}a`
+     69  69 │   
+     70     │ - "a"·+·1·+·2;·//·`a${1}${2}`
+         70 │ + `a${1}${2}`;·//·`a${1}${2}`
+     71  71 │   
+     72  72 │   1 + (2 + "a"); // `${1}${2}a`
   
 
 ```
 
 ```
-invalid.js:75:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:72:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    73 │ "a" + 1 + 2; // `a${1}${2}`
-    74 │ 
-  > 75 │ 1 + (2 + "a"); // `${1}${2}a`
+    70 │ "a" + 1 + 2; // `a${1}${2}`
+    71 │ 
+  > 72 │ 1 + (2 + "a"); // `${1}${2}a`
        │ ^^^^^^^^^^^^^
-    76 │ 
-    77 │ (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
+    73 │ 
+    74 │ (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
   
   i Unsafe fix: Use a template literal.
   
-     73  73 │   "a" + 1 + 2; // `a${1}${2}`
-     74  74 │   
-     75     │ - 1·+·(2·+·"a");·//·`${1}${2}a`
-         75 │ + `${1}${2}a`;·//·`${1}${2}a`
-     76  76 │   
-     77  77 │   (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
+     70  70 │   "a" + 1 + 2; // `a${1}${2}`
+     71  71 │   
+     72     │ - 1·+·(2·+·"a");·//·`${1}${2}a`
+         72 │ + `${1}${2}a`;·//·`${1}${2}a`
+     73  73 │   
+     74  74 │   (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
   
 
 ```
 
 ```
-invalid.js:77:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:74:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    75 │ 1 + (2 + "a"); // `${1}${2}a`
-    76 │ 
-  > 77 │ (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
+    72 │ 1 + (2 + "a"); // `${1}${2}a`
+    73 │ 
+  > 74 │ (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
        │ ^^^^^^^^^^^^^^^^^^^^^^^
-    78 │ 
-    79 │ (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
+    75 │ 
+    76 │ (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
   
   i Unsafe fix: Use a template literal.
   
-     75  75 │   1 + (2 + "a"); // `${1}${2}a`
-     76  76 │   
-     77     │ - (1·+·2)·+·(3·+·4)·+·"a";·//·`${(1·+·2)·+·(3·+·4)}a`
-         77 │ + `${(1·+·2)·+·(3·+·4)}a`;·//·`${(1·+·2)·+·(3·+·4)}a`
-     78  78 │   
-     79  79 │   (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
+     72  72 │   1 + (2 + "a"); // `${1}${2}a`
+     73  73 │   
+     74     │ - (1·+·2)·+·(3·+·4)·+·"a";·//·`${(1·+·2)·+·(3·+·4)}a`
+         74 │ + `${(1·+·2)·+·(3·+·4)}a`;·//·`${(1·+·2)·+·(3·+·4)}a`
+     75  75 │   
+     76  76 │   (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
   
 
 ```
 
 ```
-invalid.js:79:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:76:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    77 │ (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
-    78 │ 
-  > 79 │ (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
+    74 │ (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
+    75 │ 
+  > 76 │ (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
        │ ^^^^^^^^^^^^^^^^^^^^^^^^^
-    80 │ 
-    81 │ "a" + (1 + 2 + "b"); // `a${1 + 2}b`
+    77 │ 
+    78 │ "a" + (1 + 2 + "b"); // `a${1 + 2}b`
   
   i Unsafe fix: Use a template literal.
   
-     77  77 │   (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
-     78  78 │   
-     79     │ - (1·+·2)·+·((3·+·4)·+·"a");·//·`${1·+·2}${3·+·4}a`
-         79 │ + `${1·+·2}${3·+·4}a`;·//·`${1·+·2}${3·+·4}a`
-     80  80 │   
-     81  81 │   "a" + (1 + 2 + "b"); // `a${1 + 2}b`
+     74  74 │   (1 + 2) + (3 + 4) + "a"; // `${(1 + 2) + (3 + 4)}a`
+     75  75 │   
+     76     │ - (1·+·2)·+·((3·+·4)·+·"a");·//·`${1·+·2}${3·+·4}a`
+         76 │ + `${1·+·2}${3·+·4}a`;·//·`${1·+·2}${3·+·4}a`
+     77  77 │   
+     78  78 │   "a" + (1 + 2 + "b"); // `a${1 + 2}b`
   
 
 ```
 
 ```
-invalid.js:81:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:78:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    79 │ (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
-    80 │ 
-  > 81 │ "a" + (1 + 2 + "b"); // `a${1 + 2}b`
+    76 │ (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
+    77 │ 
+  > 78 │ "a" + (1 + 2 + "b"); // `a${1 + 2}b`
        │ ^^^^^^^^^^^^^^^^^^^
-    82 │ 
-    83 │ (1 + 2 + "a") + "b"; // `${1 + 2}ab`
+    79 │ 
+    80 │ (1 + 2 + "a") + "b"; // `${1 + 2}ab`
   
   i Unsafe fix: Use a template literal.
   
-     79  79 │   (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
-     80  80 │   
-     81     │ - "a"·+·(1·+·2·+·"b");·//·`a${1·+·2}b`
-         81 │ + `a${1·+·2}b`;·//·`a${1·+·2}b`
-     82  82 │   
-     83  83 │   (1 + 2 + "a") + "b"; // `${1 + 2}ab`
+     76  76 │   (1 + 2) + ((3 + 4) + "a"); // `${1 + 2}${3 + 4}a`
+     77  77 │   
+     78     │ - "a"·+·(1·+·2·+·"b");·//·`a${1·+·2}b`
+         78 │ + `a${1·+·2}b`;·//·`a${1·+·2}b`
+     79  79 │   
+     80  80 │   (1 + 2 + "a") + "b"; // `${1 + 2}ab`
   
 
 ```
 
 ```
-invalid.js:83:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:80:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    81 │ "a" + (1 + 2 + "b"); // `a${1 + 2}b`
-    82 │ 
-  > 83 │ (1 + 2 + "a") + "b"; // `${1 + 2}ab`
+    78 │ "a" + (1 + 2 + "b"); // `a${1 + 2}b`
+    79 │ 
+  > 80 │ (1 + 2 + "a") + "b"; // `${1 + 2}ab`
        │ ^^^^^^^^^^^^^^^^^^^
-    84 │ 
-    85 │ ("a" + 1 + 2) + "b"; // `a${1}${2}b`
+    81 │ 
+    82 │ ("a" + 1 + 2) + "b"; // `a${1}${2}b`
   
   i Unsafe fix: Use a template literal.
   
-     81  81 │   "a" + (1 + 2 + "b"); // `a${1 + 2}b`
-     82  82 │   
-     83     │ - (1·+·2·+·"a")·+·"b";·//·`${1·+·2}ab`
-         83 │ + `${1·+·2}ab`;·//·`${1·+·2}ab`
-     84  84 │   
-     85  85 │   ("a" + 1 + 2) + "b"; // `a${1}${2}b`
+     78  78 │   "a" + (1 + 2 + "b"); // `a${1 + 2}b`
+     79  79 │   
+     80     │ - (1·+·2·+·"a")·+·"b";·//·`${1·+·2}ab`
+         80 │ + `${1·+·2}ab`;·//·`${1·+·2}ab`
+     81  81 │   
+     82  82 │   ("a" + 1 + 2) + "b"; // `a${1}${2}b`
   
 
 ```
 
 ```
-invalid.js:85:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:82:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    83 │ (1 + 2 + "a") + "b"; // `${1 + 2}ab`
-    84 │ 
-  > 85 │ ("a" + 1 + 2) + "b"; // `a${1}${2}b`
+    80 │ (1 + 2 + "a") + "b"; // `${1 + 2}ab`
+    81 │ 
+  > 82 │ ("a" + 1 + 2) + "b"; // `a${1}${2}b`
        │ ^^^^^^^^^^^^^^^^^^^
-    86 │ 
-    87 │ ("a" + 1) + (2 + "b"); // `a${1}${2}b`
+    83 │ 
+    84 │ ("a" + 1) + (2 + "b"); // `a${1}${2}b`
   
   i Unsafe fix: Use a template literal.
   
-     83  83 │   (1 + 2 + "a") + "b"; // `${1 + 2}ab`
-     84  84 │   
-     85     │ - ("a"·+·1·+·2)·+·"b";·//·`a${1}${2}b`
-         85 │ + `a${1}${2}b`;·//·`a${1}${2}b`
-     86  86 │   
-     87  87 │   ("a" + 1) + (2 + "b"); // `a${1}${2}b`
+     80  80 │   (1 + 2 + "a") + "b"; // `${1 + 2}ab`
+     81  81 │   
+     82     │ - ("a"·+·1·+·2)·+·"b";·//·`a${1}${2}b`
+         82 │ + `a${1}${2}b`;·//·`a${1}${2}b`
+     83  83 │   
+     84  84 │   ("a" + 1) + (2 + "b"); // `a${1}${2}b`
   
 
 ```
 
 ```
-invalid.js:87:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:84:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    85 │ ("a" + 1 + 2) + "b"; // `a${1}${2}b`
-    86 │ 
-  > 87 │ ("a" + 1) + (2 + "b"); // `a${1}${2}b`
+    82 │ ("a" + 1 + 2) + "b"; // `a${1}${2}b`
+    83 │ 
+  > 84 │ ("a" + 1) + (2 + "b"); // `a${1}${2}b`
        │ ^^^^^^^^^^^^^^^^^^^^^
-    88 │ 
-    89 │ (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
+    85 │ 
+    86 │ (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
   
   i Unsafe fix: Use a template literal.
   
-     85  85 │   ("a" + 1 + 2) + "b"; // `a${1}${2}b`
-     86  86 │   
-     87     │ - ("a"·+·1)·+·(2·+·"b");·//·`a${1}${2}b`
-         87 │ + `a${1}${2}b`;·//·`a${1}${2}b`
-     88  88 │   
-     89  89 │   (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
+     82  82 │   ("a" + 1 + 2) + "b"; // `a${1}${2}b`
+     83  83 │   
+     84     │ - ("a"·+·1)·+·(2·+·"b");·//·`a${1}${2}b`
+         84 │ + `a${1}${2}b`;·//·`a${1}${2}b`
+     85  85 │   
+     86  86 │   (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
   
 
 ```
 
 ```
-invalid.js:89:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:86:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    87 │ ("a" + 1) + (2 + "b"); // `a${1}${2}b`
-    88 │ 
-  > 89 │ (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
+    84 │ ("a" + 1) + (2 + "b"); // `a${1}${2}b`
+    85 │ 
+  > 86 │ (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
        │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    90 │ 
-    91 │ "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
+    87 │ 
+    88 │ "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
   
   i Unsafe fix: Use a template literal.
   
-     87  87 │   ("a" + 1) + (2 + "b"); // `a${1}${2}b`
-     88  88 │   
-     89     │ - (1·+·2)·+·(3·+·"a")·+·4·+·(5·+·("b"·+·6));·//·`${1·+·2}${3}a${4}${5}b${6}`
-         89 │ + `${1·+·2}${3}a${4}${5}b${6}`;·//·`${1·+·2}${3}a${4}${5}b${6}`
-     90  90 │   
-     91  91 │   "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
+     84  84 │   ("a" + 1) + (2 + "b"); // `a${1}${2}b`
+     85  85 │   
+     86     │ - (1·+·2)·+·(3·+·"a")·+·4·+·(5·+·("b"·+·6));·//·`${1·+·2}${3}a${4}${5}b${6}`
+         86 │ + `${1·+·2}${3}a${4}${5}b${6}`;·//·`${1·+·2}${3}a${4}${5}b${6}`
+     87  87 │   
+     88  88 │   "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
   
 
 ```
 
 ```
-invalid.js:91:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:88:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    89 │ (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
-    90 │ 
-  > 91 │ "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
+    86 │ (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
+    87 │ 
+  > 88 │ "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
        │ ^^^^^^^^^^^^^^^^^^^^^^^
-    92 │ 
-    93 │ 1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
+    89 │ 
+    90 │ 1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
   
   i Unsafe fix: Use a template literal.
   
-     89  89 │   (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
-     90  90 │   
-     91     │ - "a"·+·1·+·(2·+·(3·+·4));·//·`a${1}${2·+·(3·+·4)}`
-         91 │ + `a${1}${2·+·(3·+·4)}`;·//·`a${1}${2·+·(3·+·4)}`
-     92  92 │   
-     93  93 │   1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
+     86  86 │   (1 + 2) + (3 + "a") + 4 + (5 + ("b" + 6)); // `${1 + 2}${3}a${4}${5}b${6}`
+     87  87 │   
+     88     │ - "a"·+·1·+·(2·+·(3·+·4));·//·`a${1}${2·+·(3·+·4)}`
+         88 │ + `a${1}${2·+·(3·+·4)}`;·//·`a${1}${2·+·(3·+·4)}`
+     89  89 │   
+     90  90 │   1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
   
 
 ```
 
 ```
-invalid.js:93:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:90:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    91 │ "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
-    92 │ 
-  > 93 │ 1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
+    88 │ "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
+    89 │ 
+  > 90 │ 1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
        │ ^^^^^^^^^^^^^^^^^^^^^^^
-    94 │ 
-    95 │ 1 - 2 + "a"; // `${1 - 2}a`
+    91 │ 
+    92 │ 1 - 2 + "a"; // `${1 - 2}a`
   
   i Unsafe fix: Use a template literal.
   
-     91  91 │   "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
-     92  92 │   
-     93     │ - 1·+·(2·+·(3·+·4))·+·"a";·//·`${1·+·(2·+·(3·+·4))}a`
-         93 │ + `${1·+·(2·+·(3·+·4))}a`;·//·`${1·+·(2·+·(3·+·4))}a`
-     94  94 │   
-     95  95 │   1 - 2 + "a"; // `${1 - 2}a`
+     88  88 │   "a" + 1 + (2 + (3 + 4)); // `a${1}${2 + (3 + 4)}`
+     89  89 │   
+     90     │ - 1·+·(2·+·(3·+·4))·+·"a";·//·`${1·+·(2·+·(3·+·4))}a`
+         90 │ + `${1·+·(2·+·(3·+·4))}a`;·//·`${1·+·(2·+·(3·+·4))}a`
+     91  91 │   
+     92  92 │   1 - 2 + "a"; // `${1 - 2}a`
   
 
 ```
 
 ```
-invalid.js:95:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:92:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    93 │ 1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
-    94 │ 
-  > 95 │ 1 - 2 + "a"; // `${1 - 2}a`
+    90 │ 1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
+    91 │ 
+  > 92 │ 1 - 2 + "a"; // `${1 - 2}a`
        │ ^^^^^^^^^^^
-    96 │ 
-    97 │ "a" + (1 - 2); // `a${1 - 2}`
+    93 │ 
+    94 │ "a" + (1 - 2); // `a${1 - 2}`
   
   i Unsafe fix: Use a template literal.
   
-     93  93 │   1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
-     94  94 │   
-     95     │ - 1·-·2·+·"a";·//·`${1·-·2}a`
-         95 │ + `${1·-·2}a`;·//·`${1·-·2}a`
-     96  96 │   
-     97  97 │   "a" + (1 - 2); // `a${1 - 2}`
+     90  90 │   1 + (2 + (3 + 4)) + "a"; // `${1·+·(2·+·(3·+·4))}a`
+     91  91 │   
+     92     │ - 1·-·2·+·"a";·//·`${1·-·2}a`
+         92 │ + `${1·-·2}a`;·//·`${1·-·2}a`
+     93  93 │   
+     94  94 │   "a" + (1 - 2); // `a${1 - 2}`
   
 
 ```
 
 ```
-invalid.js:97:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:94:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    95 │ 1 - 2 + "a"; // `${1 - 2}a`
-    96 │ 
-  > 97 │ "a" + (1 - 2); // `a${1 - 2}`
+    92 │ 1 - 2 + "a"; // `${1 - 2}a`
+    93 │ 
+  > 94 │ "a" + (1 - 2); // `a${1 - 2}`
        │ ^^^^^^^^^^^^^
-    98 │ 
-    99 │ (foo && bar) + "baz"; // `${foo && bar}baz`
+    95 │ 
+    96 │ (foo && bar) + "baz"; // `${foo && bar}baz`
   
   i Unsafe fix: Use a template literal.
   
-     95  95 │   1 - 2 + "a"; // `${1 - 2}a`
-     96  96 │   
-     97     │ - "a"·+·(1·-·2);·//·`a${1·-·2}`
-         97 │ + `a${1·-·2}`;·//·`a${1·-·2}`
-     98  98 │   
-     99  99 │   (foo && bar) + "baz"; // `${foo && bar}baz`
+     92  92 │   1 - 2 + "a"; // `${1 - 2}a`
+     93  93 │   
+     94     │ - "a"·+·(1·-·2);·//·`a${1·-·2}`
+         94 │ + `a${1·-·2}`;·//·`a${1·-·2}`
+     95  95 │   
+     96  96 │   (foo && bar) + "baz"; // `${foo && bar}baz`
   
 
 ```
 
 ```
-invalid.js:99:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:96:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-     97 │ "a" + (1 - 2); // `a${1 - 2}`
-     98 │ 
-   > 99 │ (foo && bar) + "baz"; // `${foo && bar}baz`
-        │ ^^^^^^^^^^^^^^^^^^^^
-    100 │ 
-    101 │ "foo" + (bar && baz); // `foo${bar && baz}`
+    94 │ "a" + (1 - 2); // `a${1 - 2}`
+    95 │ 
+  > 96 │ (foo && bar) + "baz"; // `${foo && bar}baz`
+       │ ^^^^^^^^^^^^^^^^^^^^
+    97 │ 
+    98 │ "foo" + (bar && baz); // `foo${bar && baz}`
   
   i Unsafe fix: Use a template literal.
   
-     97  97 │   "a" + (1 - 2); // `a${1 - 2}`
-     98  98 │   
-     99     │ - (foo·&&·bar)·+·"baz";·//·`${foo·&&·bar}baz`
-         99 │ + `${foo·&&·bar}baz`;·//·`${foo·&&·bar}baz`
-    100 100 │   
-    101 101 │   "foo" + (bar && baz); // `foo${bar && baz}`
+     94  94 │   "a" + (1 - 2); // `a${1 - 2}`
+     95  95 │   
+     96     │ - (foo·&&·bar)·+·"baz";·//·`${foo·&&·bar}baz`
+         96 │ + `${foo·&&·bar}baz`;·//·`${foo·&&·bar}baz`
+     97  97 │   
+     98  98 │   "foo" + (bar && baz); // `foo${bar && baz}`
   
 
 ```
 
 ```
-invalid.js:101:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:98:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-     99 │ (foo && bar) + "baz"; // `${foo && bar}baz`
-    100 │ 
-  > 101 │ "foo" + (bar && baz); // `foo${bar && baz}`
+     96 │ (foo && bar) + "baz"; // `${foo && bar}baz`
+     97 │ 
+   > 98 │ "foo" + (bar && baz); // `foo${bar && baz}`
         │ ^^^^^^^^^^^^^^^^^^^^
-    102 │ 
-    103 │ (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
+     99 │ 
+    100 │ (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
   
   i Unsafe fix: Use a template literal.
   
-     99  99 │   (foo && bar) + "baz"; // `${foo && bar}baz`
-    100 100 │   
-    101     │ - "foo"·+·(bar·&&·baz);·//·`foo${bar·&&·baz}`
-        101 │ + `foo${bar·&&·baz}`;·//·`foo${bar·&&·baz}`
-    102 102 │   
-    103 103 │   (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
+     96  96 │   (foo && bar) + "baz"; // `${foo && bar}baz`
+     97  97 │   
+     98     │ - "foo"·+·(bar·&&·baz);·//·`foo${bar·&&·baz}`
+         98 │ + `foo${bar·&&·baz}`;·//·`foo${bar·&&·baz}`
+     99  99 │   
+    100 100 │   (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
   
 
 ```
 
 ```
-invalid.js:103:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:100:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    101 │ "foo" + (bar && baz); // `foo${bar && baz}`
-    102 │ 
-  > 103 │ (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
+     98 │ "foo" + (bar && baz); // `foo${bar && baz}`
+     99 │ 
+  > 100 │ (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
         │ ^^^^^^^^^^^^^^^^^^^^^^^^
-    104 │ 
-    105 │ "foo" + (bar && baz + 1); // `foo${bar && baz + 1}`
+    101 │ 
+    102 │ "foo" + (bar && baz + 1); // `foo${bar && baz + 1}`
   
   i Unsafe fix: Use a template literal.
   
-    101 101 │   "foo" + (bar && baz); // `foo${bar && baz}`
-    102 102 │   
-    103     │ - (1·+·foo·&&·bar)·+·"baz";·//·`${1·+·foo·&&·bar}baz`
-        103 │ + `${1·+·foo·&&·bar}baz`;·//·`${1·+·foo·&&·bar}baz`
-    104 104 │   
-    105 105 │   "foo" + (bar && baz + 1); // `foo${bar && baz + 1}`
+     98  98 │   "foo" + (bar && baz); // `foo${bar && baz}`
+     99  99 │   
+    100     │ - (1·+·foo·&&·bar)·+·"baz";·//·`${1·+·foo·&&·bar}baz`
+        100 │ + `${1·+·foo·&&·bar}baz`;·//·`${1·+·foo·&&·bar}baz`
+    101 101 │   
+    102 102 │   "foo" + (bar && baz + 1); // `foo${bar && baz + 1}`
   
 
 ```
 
 ```
-invalid.js:105:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+invalid.js:102:1 lint/style/useTemplate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! Template literals are preferred over string concatenation.
   
-    103 │ (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
-    104 │ 
-  > 105 │ "foo" + (bar && baz + 1); // `foo${bar && baz + 1}`
+    100 │ (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
+    101 │ 
+  > 102 │ "foo" + (bar && baz + 1); // `foo${bar && baz + 1}`
         │ ^^^^^^^^^^^^^^^^^^^^^^^^
-    106 │ 
+    103 │ 
   
   i Unsafe fix: Use a template literal.
   
-    103 103 │   (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
-    104 104 │   
-    105     │ - "foo"·+·(bar·&&·baz·+·1);·//·`foo${bar·&&·baz·+·1}`
-        105 │ + `foo${bar·&&·baz·+·1}`;·//·`foo${bar·&&·baz·+·1}`
-    106 106 │   
+    100 100 │   (1 + foo && bar) + "baz"; // `${1 + foo && bar}baz`
+    101 101 │   
+    102     │ - "foo"·+·(bar·&&·baz·+·1);·//·`foo${bar·&&·baz·+·1}`
+        102 │ + `foo${bar·&&·baz·+·1}`;·//·`foo${bar·&&·baz·+·1}`
+    103 103 │   
   
 
 ```
diff --git a/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js b/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js
index 5ba10d1d986f..7219c1ef55db 100644
--- a/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js
+++ b/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js
@@ -7,4 +7,16 @@ number`5` + 1 + number`4`;
 
 `a` + "b";
 
-("a" * 2) + 5
+("a" * 2) + 5;
+
+//a
+/*b*/ foo /*c*/ + /*d*/ 'baz' /*e*/ + /*f*/ 1 //g
++ //h
+bar //i
+
+// https://github.com/biomejs/biome/issues/4947
+`${VALUE} Proident ad laborum dolor adipisicing. Consequat consequat eu deserunt in ea eiusmod.`
++ 'Veniam qui aliqua laborum tempor occaecat sunt pariatur labore esse deserunt. Aliqua fugiat';
+
+`${VALUE} Proident ad laborum dolor adipisicing. Consequat consequat eu deserunt in ea eiusmod.` +
+'Veniam qui aliqua laborum tempor occaecat sunt pariatur labore esse deserunt. Aliqua fugiat';
diff --git a/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js.snap b/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js.snap
index 04e3d501a985..3d73a478ac56 100644
--- a/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js.snap
+++ b/crates/biome_js_analyze/tests/specs/style/useTemplate/valid.js.snap
@@ -1,7 +1,6 @@
 ---
 source: crates/biome_js_analyze/tests/spec_tests.rs
 expression: valid.js
-snapshot_kind: text
 ---
 # Input
 ```js
@@ -14,6 +13,18 @@ number`5` + 1 + number`4`;
 
 `a` + "b";
 
-("a" * 2) + 5
+("a" * 2) + 5;
+
+//a
+/*b*/ foo /*c*/ + /*d*/ 'baz' /*e*/ + /*f*/ 1 //g
++ //h
+bar //i
+
+// https://github.com/biomejs/biome/issues/4947
+`${VALUE} Proident ad laborum dolor adipisicing. Consequat consequat eu deserunt in ea eiusmod.`
++ 'Veniam qui aliqua laborum tempor occaecat sunt pariatur labore esse deserunt. Aliqua fugiat';
+
+`${VALUE} Proident ad laborum dolor adipisicing. Consequat consequat eu deserunt in ea eiusmod.` +
+'Veniam qui aliqua laborum tempor occaecat sunt pariatur labore esse deserunt. Aliqua fugiat';
 
 ```