typescript-eslint · JoshuaKGoldberg · Sep 16, 2024 · Sep 29, 2023 · Feb 6, 2024 · Feb 6, 2024
diff --git a/packages/eslint-plugin/docs/rules/restrict-template-expressions.mdx b/packages/eslint-plugin/docs/rules/restrict-template-expressions.mdx
@@ -85,7 +85,7 @@ const msg2 = `arg = ${arg || 'not truthy'}`;
 
 ### `allowAny`
 
-Whether to `any` typed values in template expressions.
+Whether to allow `any` typed values in template expressions.
 
 Examples of additional **correct** code for this rule with `{ allowAny: true }`:
 
@@ -124,7 +124,7 @@ const msg1 = `arg = ${arg}`;
 
 ### `allowNever`
 
-Whether to `never` typed values in template expressions.
+Whether to allow `never` typed values in template expressions.
 
 Examples of additional **correct** code for this rule with `{ allowNever: true }`:
 
@@ -135,7 +135,7 @@ const msg1 = typeof arg === 'string' ? arg : `arg = ${arg}`;
 
 ### `allowArray`
 
-Whether to `Array` typed values in template expressions.
+Whether to allow `Array` typed values in template expressions.
 
 Examples of additional **correct** code for this rule with `{ allowArray: true }`:
 
@@ -144,6 +144,19 @@ const arg = ['foo', 'bar'];
 const msg1 = `arg = ${arg}`;
 ```
 
+### `allow`
+
+Whether to allow additional types in template expressions.
+
+This option takes the shared [`TypeOrValueSpecifier` format](/packages/type-utils/type-or-value-specifier).
+
+Examples of additional **correct** code for this rule with the default option `{ allow: [{ from: 'lib', name: 'Error' }, { from: 'lib', name: 'URL' }, { from: 'lib', name: 'URLSearchParams' }] }`:
+
+```ts showPlaygroundButton
+const error = new Error();
+const msg1 = `arg = ${error}`;
+```
+
 ## When Not To Use It
 
 If you're not worried about incorrectly stringifying non-string values in template literals, then you likely don't need this rule.

diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -12,7 +12,7 @@ import {
   OperatorPrecedence,
   readonlynessOptionsDefaults,
   readonlynessOptionsSchema,
-  typeMatchesSpecifier,
+  typeMatchesSomeSpecifier,
 } from '../util';
 
 type Options = [
@@ -238,8 +238,10 @@ export default createRule<Options, MessageId>({
 
       const type = services.getTypeAtLocation(node.callee);
 
-      return allowForKnownSafeCalls.some(allowedType =>
-        typeMatchesSpecifier(type, allowedType, services.program),
+      return typeMatchesSomeSpecifier(
+        type,
+        allowForKnownSafeCalls,
+        services.program,
       );
     }
 
@@ -407,8 +409,10 @@ export default createRule<Options, MessageId>({
 
       // The highest priority is to allow anything allowlisted
       if (
-        allowForKnownSafePromises.some(allowedType =>
-          typeMatchesSpecifier(type, allowedType, services.program),
+        typeMatchesSomeSpecifier(
+          type,
+          allowForKnownSafePromises,
+          services.program,
         )
       ) {
         return false;

diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -1,8 +1,13 @@
+import {
+  typeMatchesSomeSpecifier,
+  typeOrValueSpecifiersSchema,
+} from '@typescript-eslint/type-utils';
 import type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { Type, TypeChecker } from 'typescript';
 import { TypeFlags } from 'typescript';
 
+import type { TypeOrValueSpecifier } from '../util';
 import {
   createRule,
   getConstrainedTypeAtLocation,
@@ -43,14 +48,16 @@ const optionTesters = (
       (type, checker): boolean => getTypeName(checker, type) === 'RegExp',
     ],
     ['Never', isTypeNeverType],
-  ] satisfies [string, OptionTester][]
+  ] as const satisfies [string, OptionTester][]
 ).map(([type, tester]) => ({
   type,
   option: `allow${type}` as const,
   tester,
 }));
 type Options = [
-  { [Type in (typeof optionTesters)[number]['option']]?: boolean },
+  { [Type in (typeof optionTesters)[number]['option']]?: boolean } & {
+    allow?: TypeOrValueSpecifier[];
+  },
 ];
 
 type MessageId = 'invalidType';
@@ -84,15 +91,21 @@ export default createRule<Options, MessageId>({
       {
         type: 'object',
         additionalProperties: false,
-        properties: Object.fromEntries(
-          optionTesters.map(({ option, type }) => [
-            option,
-            {
-              description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
-              type: 'boolean',
-            },
-          ]),
-        ),
+        properties: {
+          ...Object.fromEntries(
+            optionTesters.map(({ option, type }) => [
+              option,
+              {
+                description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`,
+                type: 'boolean',
+              },
+            ]),
+          ),
+          allow: {
+            description: `Types to allow in template expressions.`,
+            ...typeOrValueSpecifiersSchema,
+          },
+        },
       },
     ],
   },
@@ -103,11 +116,13 @@ export default createRule<Options, MessageId>({
       allowNullish: true,
       allowNumber: true,
       allowRegExp: true,
+      allow: [{ from: 'lib', name: ['Error', 'URL', 'URLSearchParams'] }],
     },
   ],
-  create(context, [options]) {
+  create(context, [{ allow, ...options }]) {
     const services = getParserServices(context);
-    const checker = services.program.getTypeChecker();
+    const { program } = services;
+    const checker = program.getTypeChecker();
     const enabledOptionTesters = optionTesters.filter(
       ({ option }) => options[option],
     );
@@ -147,6 +162,7 @@ export default createRule<Options, MessageId>({
 
       return (
         isTypeFlagSet(innerType, TypeFlags.StringLike) ||
+        typeMatchesSomeSpecifier(innerType, allow, program) ||
         enabledOptionTesters.some(({ tester }) =>
           tester(innerType, checker, recursivelyCheckType),
         )

diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/restrict-template-expressions.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/restrict-template-expressions.shot
diff --git a/packages/eslint-plugin/tests/docs.test.ts b/packages/eslint-plugin/tests/docs.test.ts
@@ -153,6 +153,7 @@ describe('Validating rule docs', () => {
   const ignoredFiles = new Set([
     'README.md',
     'TEMPLATE.md',
+    'shared',
     // These rule docs were left behind on purpose for legacy reasons. See the
     // comments in the files for more information.
     'ban-types.md',

diff --git a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
@@ -344,6 +344,12 @@ ruleTester.run('restrict-template-expressions', rule, {
         }
       `,
     },
+    // allow
+    {
+      options: [{ allow: [{ from: 'lib', name: 'Promise' }] }],
+      code: 'const msg = `arg = ${Promise.resolve()}`;',
+    },
+    'const msg = `arg = ${new Error()}`;',
     'const msg = `arg = ${false}`;',
     'const msg = `arg = ${null}`;',
     'const msg = `arg = ${undefined}`;',
@@ -422,6 +428,15 @@ ruleTester.run('restrict-template-expressions', rule, {
       ],
       options: [{ allowNullish: false, allowArray: true }],
     },
+    {
+      code: 'const msg = `arg = ${Promise.resolve()}`;',
+      errors: [{ messageId: 'invalidType' }],
+    },
+    {
+      code: 'const msg = `arg = ${new Error()}`;',
+      options: [{ allow: [] }],
+      errors: [{ messageId: 'invalidType' }],
+    },
     {
       code: `
         declare const arg: [number | undefined, string];

diff --git a/packages/eslint-plugin/tests/schema-snapshots/restrict-template-expressions.shot b/packages/eslint-plugin/tests/schema-snapshots/restrict-template-expressions.shot