Dec 30, 2024 · Dec 1, 2024 · Dec 1, 2024 · Dec 1, 2024 · Dec 1, 2024 · Dec 2, 2024
diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts
  Sometimes = 'may',
 }

 type Options = [
 exporttype Options = [
  {
    ignoredTypeNames?: string[];
  },
 ];
 type MessageIds = 'baseArrayJoin' | 'baseToString';
 exporttype MessageIds = 'baseArrayJoin' | 'baseToString';

 export default createRule<Options, MessageIds>({
  name: 'no-base-to-string',
      return Usefulness.Never;
    }

    function collectTupleCertainty(type: ts.TypeReference): Usefulness {
      const typeArgs = checker.getTypeArguments(type);
      const certainties = typeArgs.map(t => collectToStringCertainty(t));
      if (certainties.some(certainty => certainty === Usefulness.Never)) {
        return Usefulness.Never;
      }

      if (certainties.some(certainty => certainty === Usefulness.Sometimes)) {
        return Usefulness.Sometimes;
      }

      return Usefulness.Always;
    }

    function collectArrayCertainty(type: ts.Type): Usefulness {
      const elemType = nullThrows(
        type.getNumberIndexType(),
        'array should have number index type',
      );
      return collectToStringCertainty(elemType);
    }

    function collectJoinCertainty(type: ts.Type): Usefulness {
      if (tsutils.isUnionType(type)) {
        return collectUnionTypeCertainty(type, collectJoinCertainty);
      }

      if (checker.isTupleType(type)) {
        const typeArgs = checker.getTypeArguments(type);
        const certainties = typeArgs.map(t => collectToStringCertainty(t));
        if (certainties.some(certainty => certainty === Usefulness.Never)) {
          return Usefulness.Never;
        }

        if (certainties.some(certainty => certainty === Usefulness.Sometimes)) {
          return Usefulness.Sometimes;
        }

        return Usefulness.Always;
        return collectTupleCertainty(type);
      }

      if (checker.isArrayType(type)) {
        const elemType = nullThrows(
          type.getNumberIndexType(),
          'array should have number index type',
        );
        return collectToStringCertainty(elemType);
        return collectArrayCertainty(type);
      }

      return Usefulness.Always;
        return collectUnionTypeCertainty(type, collectToStringCertainty);
      }

      if (checker.isTupleType(type)) {
        return collectTupleCertainty(type);
      }

      if (checker.isArrayType(type)) {
        return collectArrayCertainty(type);
      }

      const toString =
        checker.getPropertyOfType(type, 'toString') ??
        checker.getPropertyOfType(type, 'toLocaleString');
Original file line number	Diff line number	Diff line change
Expand Up		@@ -18,12 +18,12 @@ enum Usefulness {
		Sometimes = 'may',
		}

		type Options = [
		exporttype Options = [
		{
		ignoredTypeNames?: string[];
		},
		];
		type MessageIds = 'baseArrayJoin' \| 'baseToString';
		exporttype MessageIds = 'baseArrayJoin' \| 'baseToString';

		export default createRule<Options, MessageIds>({
		name: 'no-base-to-string',
Expand DownExpand Up		@@ -140,6 +140,28 @@ export default createRule<Options, MessageIds>({
		return Usefulness.Never;
		}

		function collectTupleCertainty(type: ts.TypeReference): Usefulness {
		const typeArgs = checker.getTypeArguments(type);
		const certainties = typeArgs.map(t => collectToStringCertainty(t));
		if (certainties.some(certainty => certainty === Usefulness.Never)) {
		return Usefulness.Never;
		}

		if (certainties.some(certainty => certainty === Usefulness.Sometimes)) {
		return Usefulness.Sometimes;
		}

		return Usefulness.Always;
		}

		function collectArrayCertainty(type: ts.Type): Usefulness {
		const elemType = nullThrows(
		type.getNumberIndexType(),
		'array should have number index type',
		);
		return collectToStringCertainty(elemType);
		}

		function collectJoinCertainty(type: ts.Type): Usefulness {
		if (tsutils.isUnionType(type)) {
		return collectUnionTypeCertainty(type, collectJoinCertainty);
Expand All		@@ -150,25 +172,11 @@ export default createRule<Options, MessageIds>({
		}

		if (checker.isTupleType(type)) {
		const typeArgs = checker.getTypeArguments(type);
		const certainties = typeArgs.map(t => collectToStringCertainty(t));
		if (certainties.some(certainty => certainty === Usefulness.Never)) {
		return Usefulness.Never;
		}

		if (certainties.some(certainty => certainty === Usefulness.Sometimes)) {
		return Usefulness.Sometimes;
		}

		return Usefulness.Always;
		return collectTupleCertainty(type);
		}

		if (checker.isArrayType(type)) {
		const elemType = nullThrows(
		type.getNumberIndexType(),
		'array should have number index type',
		);
		return collectToStringCertainty(elemType);
		return collectArrayCertainty(type);
		}

		return Usefulness.Always;
Expand DownExpand Up		@@ -205,6 +213,14 @@ export default createRule<Options, MessageIds>({
		return collectUnionTypeCertainty(type, collectToStringCertainty);
		}

		if (checker.isTupleType(type)) {
		return collectTupleCertainty(type);
		}

		if (checker.isArrayType(type)) {
		return collectArrayCertainty(type);
		}

		const toString =
		checker.getPropertyOfType(type, 'toString') ??
		checker.getPropertyOfType(type, 'toLocaleString');
Expand Down