eslint-config-typed 1.0.0

package/src/plugins/total-functions/rules/no-hidden-type-assertions.mts

@@ -0,0 +1,207 @@
+import {
+  isTypeNeverType,
+  isTypeUnknownType,
+} from '@typescript-eslint/type-utils';
+import { ESLintUtils } from '@typescript-eslint/utils';
+import {
+  isArrayTypeNode,
+  isConditionalTypeNode,
+  isFunctionTypeNode,
+  isIndexedAccessTypeNode,
+  isIntersectionTypeNode,
+  isNamedTupleMember,
+  isTupleTypeNode,
+  isTypeLiteralNode,
+  isTypeNode,
+  isTypeOperatorNode,
+  isTypeReferenceNode,
+  isUnionTypeNode,
+  type NodeArray,
+  type ParameterDeclaration,
+  SyntaxKind,
+  type TypeElement,
+  type TypeNode,
+} from 'typescript';
+import { createRule } from './common.mjs';
+
+/** An ESLint rule to ban hidden type assertions. */
+
+export const noHiddenTypeAssertions = createRule({
+  name: 'no-hidden-type-assertions',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Bans hidden type assertions.',
+    },
+    messages: {
+      errorStringGeneric:
+        'Do not use hidden type assertions. Specify `unknown` or `never` instead of an arbitrary type argument.',
+    },
+    schema: [],
+  },
+  create: (context) => {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+
+    const explodeTypeNode = (
+      type: TypeNode,
+      depth: number,
+    ): readonly TypeNode[] => {
+      // TODO write a test that exercises this
+
+      if (depth >= 100) {
+        return [] as const;
+      }
+
+      const next = isTypeReferenceNode(type)
+        ? (type.typeArguments ?? [])
+        : isConditionalTypeNode(type)
+          ? [type.checkType, type.trueType, type.falseType]
+          : isIndexedAccessTypeNode(type)
+            ? [type.objectType, type.indexType]
+            : isFunctionTypeNode(type)
+              ? [type.type, ...parametersToTypeNodes(type.parameters, depth)]
+              : isTupleTypeNode(type)
+                ? type.elements
+                : isNamedTupleMember(type)
+                  ? [type.type]
+                  : isTypeLiteralNode(type)
+                    ? type.members.flatMap((m) =>
+                        hasTypeNode(m) ? [m.type] : [],
+                      )
+                    : isArrayTypeNode(type)
+                      ? [type.elementType]
+                      : isTypeOperatorNode(type)
+                        ? [type.type]
+                        : isUnionTypeNode(type)
+                          ? type.types
+                          : isIntersectionTypeNode(type)
+                            ? type.types
+                            : [];
+
+      return [type, ...next.flatMap(explodeTypeNode)] as const;
+    };
+
+    const parametersToTypeNodes = (
+      parameters: NodeArray<ParameterDeclaration>,
+      depth: number,
+    ): readonly TypeNode[] =>
+      parameters
+        .flatMap((parameter) =>
+          parameter.type !== undefined ? [parameter.type] : [],
+        )
+        .flatMap((parameter) => explodeTypeNode(parameter, depth));
+
+    return {
+      CallExpression: (node) => {
+        const tsExpressionNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        const callSignature = checker.getResolvedSignature(tsExpressionNode);
+
+        if (callSignature?.declaration === undefined) {
+          return;
+        }
+
+        if (callSignature.declaration.kind === SyntaxKind.JSDocSignature) {
+          // TODO support JSDoc
+          return;
+        }
+
+        const typeParameters = callSignature.declaration.typeParameters;
+        const parameters = parametersToTypeNodes(
+          callSignature.declaration.parameters,
+          0,
+        );
+
+        const returnType = callSignature.declaration.type;
+
+        if (
+          returnType === undefined ||
+          typeParameters === undefined ||
+          typeParameters.length === 0
+        ) {
+          return;
+        }
+
+        const returnTypes = explodeTypeNode(returnType, 0);
+
+        // Of all the type parameters, these are the ones that are used in the
+        // return type (alongside their positional index, which we use next to
+        // look up corresponding type arguments)
+        const typeParamsUsedInReturnType = typeParameters
+          .map((typeParameter, index) => ({ typeParameter, index }))
+          .filter((typeParameter) =>
+            returnTypes.some(
+              (retType) =>
+                isTypeReferenceNode(retType) &&
+                retType.typeName.kind === SyntaxKind.Identifier &&
+                retType.typeName.text === typeParameter.typeParameter.name.text,
+            ),
+          );
+
+        // Of all the type parameters that appear in the return type,
+        // are they all set to `unknown` type arguments in this specific call?
+        // If so, this is safe even if the function being called is a hidden type assertion.
+        const allCorrespondingTypeArgumentsAreUnknownType =
+          typeParamsUsedInReturnType.every(({ typeParameter, index }) => {
+            const typeArgument = (tsExpressionNode.typeArguments ?? [])[index];
+            const typeArgumentType =
+              typeArgument !== undefined
+                ? checker.getTypeAtLocation(typeArgument)
+                : undefined;
+
+            const typeParamDefaultType =
+              typeParameter.default !== undefined
+                ? checker.getTypeAtLocation(typeParameter.default)
+                : undefined;
+
+            const typeToCheck = typeArgumentType ?? typeParamDefaultType;
+
+            return (
+              typeToCheck !== undefined &&
+              (isTypeUnknownType(typeToCheck) || isTypeNeverType(typeToCheck))
+            );
+          });
+
+        if (allCorrespondingTypeArgumentsAreUnknownType) {
+          return;
+        }
+
+        // Confirms that all the type parameters that appear in the return type ALSO
+        // appear in at least one (value) parameter. If they do, this probably isn't
+        // a hidden type assertion.
+        const allTypeParamsUsedInReturnTypeAlsoAppearInValueParams =
+          typeParamsUsedInReturnType
+            .map(({ typeParameter }) => typeParameter)
+            .every((typeParameter) =>
+              parameters.some(
+                (parameter) =>
+                  isTypeReferenceNode(parameter) &&
+                  parameter.typeName.kind === SyntaxKind.Identifier &&
+                  typeParameter.name.text === parameter.typeName.text,
+              ),
+            );
+
+        if (!allTypeParamsUsedInReturnTypeAlsoAppearInValueParams) {
+          context.report({
+            node,
+            messageId: 'errorStringGeneric',
+          } as const);
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const);
+
+const hasTypeNode = (
+  typeElement: TypeElement,
+): typeElement is TypeElement & Readonly<{ type: TypeNode }> => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const typeAttr = (typeElement as Partial<Readonly<{ type: TypeNode }>>)
+      .type;
+    return typeAttr !== undefined && isTypeNode(typeAttr);
+  } catch {
+    return false;
+  }
+};

package/src/plugins/total-functions/rules/no-hidden-type-assertions.test.mts

@@ -0,0 +1,287 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { noHiddenTypeAssertions } from './no-hidden-type-assertions.mjs';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      sourceType: 'module',
+      project: './tsconfig.tests.json',
+    },
+    parser,
+  },
+});
+
+ruleTester.run('no-hidden-type-assertions', noHiddenTypeAssertions, {
+  valid: [
+    // No call signature
+    {
+      filename: 'file.ts',
+      code: `
+        foo()
+      `,
+    },
+    // Hidden type assertion but set to `unknown`
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: string) => Promise<T>;
+        }
+        declare const axios: Axios;
+        export const result: Promise<unknown> = axios.request<unknown>("hello");
+      `,
+    },
+    // Hidden type assertion but set to `never`
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T>() => Promise<T>;
+        }
+        declare const axios: Axios;
+        export const result = axios.request<never>();
+      `,
+    },
+    // Generic used in input value, explicitly provided
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: T) => T;
+        }
+        declare const axios: Axios;
+        export const result: string = axios.request<string>("hello");
+      `,
+    },
+    // Generic used in input value, not explicitly provided
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: T) => Promise<T>;
+        }
+        declare const axios: Axios;
+        export const result = axios.request("hello");
+      `,
+    },
+    // Generic used in input value, not explicitly provided, no default
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T>(url: T) => Promise<T>;
+        }
+        declare const axios: Axios;
+        export const result = axios.request("hello");
+      `,
+    },
+    // No generic
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: (url: string) => Promise<string>;
+        }
+        declare const axios: Axios;
+        export const result: Promise<string> = axios.request("hello");
+      `,
+    },
+    // Reused generic name
+    {
+      filename: 'file.ts',
+      code: `
+        declare const foo: <T = any>(
+          a: string,
+          b: T
+        ) => typeof a extends (infer T)[] ? T : typeof a;
+        export const result = foo("hello", "world");
+      `,
+    },
+    // function type parameter
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: () => T) => Promise<T>;
+        }
+        declare const axios: Axios;
+        export const result = axios.request(() => "hello");
+      `,
+    },
+    // chainFirstIOK
+    {
+      filename: 'file.ts',
+      code: `
+        declare const chainFirstIOK: <A, B>(
+          f: (a: A) => Promise<B>
+        ) => (first: Promise<A>) => Promise<A>;
+
+        export const result = chainFirstIOK<string, boolean>(() =>
+          Promise.resolve(true)
+        );
+      `,
+    },
+    // object literal type hidden type assertion but set to unknown
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: string) => { t: T };
+        }
+        declare const axios: Axios;
+        export const result = axios.request<unknown>("hello");
+      `,
+    },
+    // type param has default set to never
+    {
+      filename: 'file.ts',
+      code: `
+        declare const right: <E = never, A = never>(a: A) => E | A;
+        export const result = right("hello");
+      `,
+    },
+    // toArray
+    {
+      filename: 'file.ts',
+      code: `
+        export declare const toArray: <A>(val: readonly A[]) => A[];
+        const ra = [""] as const;
+        export const result = toArray(ra);
+      `,
+    },
+  ],
+  invalid: [
+    // Hidden type assertion set to arbitrary type
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: string) => Promise<T>;
+        }
+
+        declare const axios: Axios;
+
+        export const result: Promise<boolean> = axios.request<boolean>("hello");
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    // Hidden type assertion set to parameter type coincidentally
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: string) => Promise<T>;
+        }
+
+        declare const axios: Axios;
+
+        export const result: Promise<string> = axios.request<string>("hello");
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: string) => T;
+        }
+
+        declare const axios: Axios;
+
+        export const result: boolean = axios.request<boolean>("hello");
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    // index into type
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T extends { a: U }, U>(url: string) => Promise<T["a"]>;
+        }
+
+        declare const axios: Axios;
+
+        export const result = axios.request("hello");
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    // conditional type
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T>(
+            url: string
+          ) => T extends 42 ? 43 : 45;
+        }
+
+        declare const axios: Axios;
+
+        export const result = axios.request<"asdf">("hello");
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    // object literal type
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: string) => { t: { t2: T } };
+        }
+        declare const axios: Axios;
+        export const result = axios.request<boolean>("hello");
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    // tuple
+    {
+      filename: 'file.ts',
+      code: `
+        declare class Axios {
+          readonly request: <T = any>(url: string) => { t: [T] };
+        }
+        declare const axios: Axios;
+        export const result = axios.request<boolean>("hello");
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+  ],
+} as const);

package/src/plugins/total-functions/rules/no-nested-fp-ts-effects.mts

@@ -0,0 +1,67 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { isThenableType } from 'tsutils';
+import { createRule, typeSymbolName } from './common.mjs';
+import { effects, fpTsEffectType } from './fp-ts.mjs';
+
+/** An ESLint rule to ban problematic nested fp-ts effects. */
+
+export const noNestedFpTsEffects = createRule({
+  name: 'no-nested-fp-ts-effects',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Bans problematic nested fp-ts effects.',
+    },
+    messages: {
+      errorStringGeneric: 'Do not nest these fp-ts effects.',
+    },
+    schema: [],
+  },
+  create: (context) => {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      CallExpression: (node) => {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        const expressionType = checker.getTypeAtLocation(tsNode);
+
+        const effectType = fpTsEffectType(expressionType);
+
+        if (effectType === undefined) {
+          return;
+        }
+
+        // TODO report other types of problematic nesting besides Tasks within IOs.
+
+        if (
+          effectType.effectName === 'IO' &&
+          effectType.effectTypeParameter !== undefined
+        ) {
+          const effectTypeParameterName = typeSymbolName(
+            effectType.effectTypeParameter,
+          );
+
+          if (effectTypeParameterName === undefined) {
+            return;
+          }
+          const isNestedEffect = effects.includes(effectTypeParameterName);
+
+          const isNestedPromise = isThenableType(
+            checker,
+            tsNode,
+            effectType.effectTypeParameter,
+          );
+
+          if (isNestedEffect || isNestedPromise) {
+            context.report({
+              node,
+              messageId: 'errorStringGeneric',
+            } as const);
+          }
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const);

package/src/plugins/total-functions/rules/no-nested-fp-ts-effects.test.mts

@@ -0,0 +1,150 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { noNestedFpTsEffects } from './no-nested-fp-ts-effects.mjs';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      sourceType: 'module',
+      project: './tsconfig.tests.json',
+    },
+    parser,
+  },
+});
+
+ruleTester.run('no-async-effect-within-io', noNestedFpTsEffects, {
+  valid: [
+    // CallExpression with no symbol is okay
+    {
+      filename: 'file.ts',
+      code: `
+        (() => undefined)();
+      `,
+    },
+    // Some other type with coincidentally the same name is okay (zero call signatures)
+    {
+      filename: 'file.ts',
+      code: `
+        export interface IO<A> {
+          a: A;
+        }
+
+        export interface Task<A> {
+          a: A;
+        }
+
+        const liftIO = <A>(val: A): IO<A> => ({ a: val });
+
+        const liftTask = <A>(val: A): Task<A> => ({ a: val });
+
+        const foo = liftIO(liftTask("a"));
+      `,
+    },
+    // Some other type with coincidentally the same name is okay (multiple call signatures)
+    {
+      filename: 'file.ts',
+      code: `
+        export interface IO<A> {
+          (): A;
+          (a: string): void;
+        }
+
+        export interface Task<A> {
+          (): Promise<A>;
+          (a: string): void;
+        }
+
+        declare const liftIO: <A>(val: A) => IO<A>;
+
+        declare const liftTask: <A>(val: A) => Task<A>;
+
+        const foo = liftIO(liftTask("a"));
+      `,
+    },
+    // IO<string> is okay
+    {
+      filename: 'file.ts',
+      code: `
+        export interface IO<A> {
+          (): A;
+        }
+
+        declare const liftIO: <A>(val: A) => IO<A>;
+
+        const bar = liftIO("a");
+      `,
+    },
+  ],
+  invalid: [
+    // IO<Task<A>> is invalid
+    {
+      filename: 'file.ts',
+      code: `
+        export interface IO<A> {
+          (): A;
+        }
+
+        export interface Task<A> {
+          (): Promise<A>;
+        }
+
+        declare const liftIO: <A>(val: A) => IO<A>;
+
+        declare const liftTask: <A>(val: A) => Task<A>;
+
+        const foo = liftIO(liftTask("a"));
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    // IO<TaskEither<A>> is invalid
+    {
+      filename: 'file.ts',
+      code: `
+        export interface IO<A> {
+          (): A;
+        }
+
+        export interface TaskEither<A> {
+          (): Promise<A>;
+        }
+
+        declare const liftIO: <A>(val: A) => IO<A>;
+
+        declare const liftTaskEither: <A>(val: A) => TaskEither<A>;
+
+        const foo = liftIO(liftTaskEither("a"));
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+    // IO<Promise<A>> is invalid
+    {
+      filename: 'file.ts',
+      code: `
+        export interface IO<A> {
+          (): A;
+        }
+
+        declare const liftIO: <A>(val: A) => IO<A>;
+
+        const foo = liftIO(Promise.resolve("a"));
+      `,
+      errors: [
+        {
+          messageId: 'errorStringGeneric',
+          type: AST_NODE_TYPES.CallExpression,
+        },
+      ],
+    },
+  ],
+} as const);