Turn folding an either into an option into an option.fromEither

src/rules/prefer-constructor.ts

@@ -0,0 +1,204 @@
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/experimental-utils"
+import { option, readonlyArray, readonlyNonEmptyArray } from "fp-ts"
+import { constant, flow, pipe } from "fp-ts/function"
+import { calleeIdentifier, ContextUtils, contextUtils, createRule, isCallee, isFromModule, Module } from "../utils"
+
+const hasName = (name: string) => (identifier: TSESTree.Identifier) => identifier.name === name
+
+const hasLength = (length: number) => <T>(array: ReadonlyArray<T>) => array.length === length
+
+const isArrowFunctionExpression = (node: TSESTree.Node): node is TSESTree.ArrowFunctionExpression => node.type === AST_NODE_TYPES.ArrowFunctionExpression
+
+const isCallExpression = (node: TSESTree.Node): node is TSESTree.CallExpression => node.type === AST_NODE_TYPES.CallExpression
+
+const isMemberExpression = (node: TSESTree.Node): node is TSESTree.MemberExpression => node.type === AST_NODE_TYPES.MemberExpression
+
+const isIdentifier = (node: TSESTree.Node): node is TSESTree.Identifier => node.type === AST_NODE_TYPES.Identifier
+
+const getArguments = (call: TSESTree.CallExpression) => pipe(
+  call.arguments,
+  readonlyNonEmptyArray.fromArray
+)
+
+const getFirstArgument = (call: TSESTree.CallExpression) => pipe(
+  call,
+  getArguments,
+  option.map(readonlyNonEmptyArray.head)
+)
+
+const getParams = (call: TSESTree.FunctionLike) => pipe(
+  call.params,
+  readonlyNonEmptyArray.fromArray
+)
+
+const getFirstParam = (call: TSESTree.FunctionLike) => pipe(
+  call,
+  getParams,
+  option.map(readonlyNonEmptyArray.head)
+)
+
+const isIdentifierWithName = (name: string) => (node: TSESTree.Node) => pipe(
+  node,
+  option.of,
+  option.filter(isIdentifier),
+  option.exists(hasName(name))
+)
+
+const hasPropertyIdentifierWithName = (name: string) => (node: TSESTree.MemberExpression) => pipe(
+  node.property,
+  isIdentifierWithName(name)
+)
+
+const getWrappedCall = (node: TSESTree.ArrowFunctionExpression) => pipe(
+  node.body,
+  option.of,
+  option.filter(isCallExpression),
+  option.filter(flow(
+    option.of,
+    option.bindTo("call"),
+    option.bind("param", () => pipe(node, getFirstParam, option.filter(isIdentifier))),
+    option.exists(({ call, param }) => pipe(call, hasArguments([isIdentifierWithName(param.name)])))
+  ))
+)
+
+const isCall = <T extends TSESTree.Node>(utils: ContextUtils, module: Module, name: string) => (node: T) => pipe(
+  node,
+  option.fromPredicate(isArrowFunctionExpression),
+  option.chain(getWrappedCall),
+  option.altW(constant(option.some(node))),
+  option.filter(isCallee),
+  option.exists(isCallTo(utils, module, name))
+)
+
+const isCallTo = ({ typeOfNode }: ContextUtils, module: Module, name: string) => flow(
+  calleeIdentifier,
+  option.filter(hasName(name)),
+  option.chain(typeOfNode),
+  option.exists(isFromModule(module))
+)
+
+const isLazyValue = (utils: ContextUtils, module: Module, name: string) => flow(
+  findMemberExpression(utils),
+  option.exists(isValue(utils, module, name))
+)
+
+const isValue = ({ typeOfNode }: ContextUtils, module: Module, name: string) => (node: TSESTree.MemberExpression) => pipe(
+  node,
+  option.of,
+  option.filter(hasPropertyIdentifierWithName(name)),
+  option.chain(typeOfNode),
+  option.exists(isFromModule(module))
+)
+
+const findMemberExpressionFromArrowFunctionExpression = (node: TSESTree.ArrowFunctionExpression) => pipe(
+  node.body,
+  option.of,
+  option.filter(isMemberExpression)
+)
+
+const isConstantCall = ({ typeOfNode }: ContextUtils) => (node: TSESTree.CallExpression) => pipe(
+  node,
+  calleeIdentifier,
+  option.filter(hasName("constant")),
+  option.chain(typeOfNode),
+  option.exists(isFromModule("function"))
+)
+
+const findMemberExpressionFromCallExpression = (utils: ContextUtils) => (node: TSESTree.CallExpression) => pipe(
+  node,
+  option.of,
+  option.filter(isConstantCall(utils)),
+  option.chain(getFirstArgument),
+  option.filter(isMemberExpression)
+)
+
+const findMemberExpression = (utils: ContextUtils) => (node: TSESTree.Expression) => {
+  switch (node.type) {
+    case AST_NODE_TYPES.ArrowFunctionExpression:
+      return findMemberExpressionFromArrowFunctionExpression(node)
+    case AST_NODE_TYPES.CallExpression:
+      return findMemberExpressionFromCallExpression(utils)(node)
+    default:
+      return option.none
+  }
+}
+
+const findNamespace = (utils: ContextUtils) => flow(
+  findMemberExpression(utils),
+  option.map((node) => node.object),
+  option.filter(isIdentifier),
+  option.map((identifier) => identifier.name)
+)
+
+const hasArguments = (args: ReadonlyArray<(node: TSESTree.Expression) => boolean>) => flow(
+  ensureArguments(args),
+  option.isSome
+)
+
+const ensureArguments = (args: ReadonlyArray<(node: TSESTree.Expression) => boolean>) => flow(
+  getArguments,
+  option.filter(pipe(args.length, hasLength)),
+  option.chain(
+    readonlyNonEmptyArray.traverseWithIndex(option.option)(
+      (i, value) => pipe(args, readonlyArray.lookup(i), option.filter(test => test(value)), option.map(constant(value)))
+    )
+  )
+)
+
+export default createRule({
+  name: "prefer-constructor",
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    schema: [],
+    docs: {
+      category: "Best Practices",
+      description: "afsafaf",
+      recommended: "warn"
+    },
+    messages: {
+      eitherFoldIsOptionFromEither: "cacsaffg",
+      replaceEitherFoldWithOptionFromEither: "dsagdgdsg"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const utils = contextUtils(context)
+    return {
+      CallExpression(node) {
+        pipe(
+          node,
+          option.of,
+          option.filter(isCall(utils, "Either", "fold")),
+          option.chain(ensureArguments([
+            isLazyValue(utils, "Option", "none"),
+            isCall(utils, "Option", "some")
+          ])),
+          option.bind("namespace", flow(readonlyNonEmptyArray.head, findNamespace(utils))),
+          option.map(({ namespace }) => {
+            context.report({
+              loc: {
+                start: node.loc.start,
+                end: node.loc.end
+              },
+              messageId: "eitherFoldIsOptionFromEither",
+              suggest: [
+                {
+                  messageId: "replaceEitherFoldWithOptionFromEither",
+                  fix(fixer) {
+                    return [
+                      fixer.replaceTextRange(
+                        node.range,
+                        `${namespace}.fromEither`
+                      )
+                    ]
+                  }
+                }
+              ]
+            })
+          })
+        )
+      }
+    }
+  }
+})

src/utils.ts

@@ -8,8 +8,8 @@ import {
 } from "@typescript-eslint/experimental-utils";
 import * as recast from "recast";
 import { visitorKeys as tsVisitorKeys } from "@typescript-eslint/typescript-estree";
-import { array, option, apply } from "fp-ts";
-import { pipe } from "fp-ts/function";
+import { array, option, apply, readonlyNonEmptyArray } from "fp-ts"
+import { flow, pipe } from "fp-ts/function"
 
 import estraverse from "estraverse";
 import {
@@ -32,19 +32,29 @@ declare module "typescript" {
   function toFileNameLowerCase(x: string): string;
 }
 
+const modules = ["Either", "Option", "function"] as const
+
+export type Module = typeof modules[number]
+
+const is = <T>(original: T) => (value: unknown): value is T => original === value
+
+const isModule = (name: string): name is Module => modules.includes(name as Module)
+
 const version = require("../package.json").version;
 
 export const createRule = ESLintUtils.RuleCreator(
   (name) =>
     `https://github.com/buildo/eslint-plugin-fp-ts/blob/v${version}/docs/rules/${name}.md`
 );
 
-export function calleeIdentifier(
-  node:
-    | TSESTree.CallExpression
-    | TSESTree.MemberExpression
-    | TSESTree.Identifier
-): option.Option<TSESTree.Identifier> {
+export type Callee =
+  | TSESTree.CallExpression
+  | TSESTree.MemberExpression
+  | TSESTree.Identifier
+
+export const isCallee = (node: TSESTree.Node): node is Callee => isWithinTypes(node, [AST_NODE_TYPES.CallExpression, AST_NODE_TYPES.MemberExpression, AST_NODE_TYPES.Identifier])
+
+export function calleeIdentifier(node: Callee): option.Option<TSESTree.Identifier> {
   switch (node.type) {
     case AST_NODE_TYPES.MemberExpression:
       if (node.property.type === AST_NODE_TYPES.Identifier) {
@@ -189,6 +199,41 @@ export function inferQuote(node: TSESTree.Literal): Quote {
   return node.raw[0] === "'" ? "'" : '"';
 }
 
+const getDeclarationFileName = (declaration: ts.Declaration) => declaration.getSourceFile().fileName
+
+const getDeclarations = flow(
+  (symbol: ts.Symbol) => symbol.getDeclarations(),
+  option.fromNullable,
+  option.chain(readonlyNonEmptyArray.fromArray)
+)
+
+const getFileName = flow(
+  (type: ts.Type) => type.aliasSymbol ?? type.symbol,
+  option.fromNullable,
+  option.chain(getDeclarations),
+  option.map(readonlyNonEmptyArray.head),
+  option.map(getDeclarationFileName)
+)
+
+const getFpTsModule = flow(
+  (fileName: string) => /\/fp-ts\/lib\/(.+?)\.d\.ts$/.exec(fileName),
+  option.fromNullable,
+  option.chain(array.lookup(1)),
+  option.filter(isModule)
+)
+
+const getModule = flow(
+  getFileName,
+  option.chain(getFpTsModule)
+)
+
+export const isFromModule = (module: Module) => flow(
+  getModule,
+  option.exists(is(module))
+)
+
+export type ContextUtils = ReturnType<typeof contextUtils>
+
 export const contextUtils = <
   TMessageIds extends string,
   TOptions extends readonly unknown[]
@@ -460,6 +505,7 @@ export const contextUtils = <
   }
 
   return {
+    findModuleImport,
     addNamedImportIfNeeded,
     removeImportDeclaration,
     isFlowExpression,