@definitelytyped/dtslint 0.0.141 → 0.0.142-next.12

package/dist/rules/no-any-union.d.ts

@@ -0,0 +1,4 @@
+declare const rule: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"anyUnion", never[], {
+    TSUnionType(node: import("@typescript-eslint/types/dist/generated/ast-spec").TSUnionType): void;
+}>;
+export = rule;

package/dist/rules/no-any-union.js

@@ -0,0 +1,34 @@
+"use strict";
+const util_1 = require("../util");
+const utils_1 = require("@typescript-eslint/utils");
+const rule = (0, util_1.createRule)({
+    name: "no-any-union",
+    defaultOptions: [],
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Forbid a union to contain `any`",
+            recommended: "error",
+        },
+        messages: {
+            anyUnion: "Including `any` in a union will override all other members of the union.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            TSUnionType(node) {
+                const hasAnyType = node.types.some((t) => t.type === utils_1.AST_NODE_TYPES.TSAnyKeyword);
+                if (hasAnyType) {
+                    context.report({
+                        messageId: "anyUnion",
+                        node,
+                    });
+                }
+            },
+        };
+    },
+});
+module.exports = rule;
+//# sourceMappingURL=no-any-union.js.map

package/dist/rules/no-any-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-any-union.js","sourceRoot":"","sources":["../../src/rules/no-any-union.ts"],"names":[],"mappings":";AAAA,kCAAqC;AACrC,oDAA0D;AAE1D,MAAM,IAAI,GAAG,IAAA,iBAAU,EAAC;IACtB,IAAI,EAAE,cAAc;IACpB,cAAc,EAAE,EAAE;IAClB,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACJ,WAAW,EAAE,iCAAiC;YAC9C,WAAW,EAAE,OAAO;SACrB;QACD,QAAQ,EAAE;YACR,QAAQ,EAAE,0EAA0E;SACrF;QACD,MAAM,EAAE,EAAE;KACX;IACD,MAAM,CAAC,OAAO;QACZ,OAAO;YACL,gEAAgE;YAChE,WAAW,CAAC,IAAI;gBACd,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,sBAAc,CAAC,YAAY,CAAC,CAAC;gBAClF,IAAI,UAAU,EAAE;oBACd,OAAO,CAAC,MAAM,CAAC;wBACb,SAAS,EAAE,UAAU;wBACrB,IAAI;qBACL,CAAC,CAAC;iBACJ;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,iBAAS,IAAI,CAAC"}

package/dist/rules/no-unnecessary-generics.d.ts

@@ -0,0 +1,8 @@
+import { TSESTree } from "@typescript-eslint/utils";
+declare type ESTreeFunctionLikeWithTypeParameters = TSESTree.FunctionLike & {
+    typeParameters: {};
+};
+declare const rule: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"never" | "sole", never[], {
+    [x: string]: (esNode: ESTreeFunctionLikeWithTypeParameters) => void;
+}>;
+export = rule;

package/dist/rules/no-unnecessary-generics.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const rule = (0, util_1.createRule)({
+    defaultOptions: [],
+    meta: {
+        docs: {
+            description: "Forbids signatures using a generic parameter only once.",
+            recommended: "error",
+        },
+        messages: {
+            never: "Type parameter {{name}} is never used.",
+            sole: "Type parameter {{name}} is used only once.",
+        },
+        schema: [],
+        type: "problem",
+    },
+    name: "no-relative-import-in-test",
+    create(context) {
+        return {
+            [[
+                "ArrowFunctionExpression[typeParameters]",
+                "FunctionDeclaration[typeParameters]",
+                "FunctionExpression[typeParameters]",
+                "TSCallSignatureDeclaration[typeParameters]",
+                "TSConstructorType[typeParameters]",
+                "TSDeclareFunction[typeParameters]",
+                "TSFunctionType[typeParameters]",
+                "TSMethodSignature[typeParameters]",
+            ].join(", ")](esNode) {
+                const parserServices = utils_1.ESLintUtils.getParserServices(context);
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(esNode);
+                if (!tsNode.typeParameters) {
+                    return;
+                }
+                const checker = parserServices.program.getTypeChecker();
+                for (const typeParameter of tsNode.typeParameters) {
+                    const name = typeParameter.name.text;
+                    const res = getSoleUse(tsNode, assertDefined(checker.getSymbolAtLocation(typeParameter.name)), checker);
+                    switch (res.type) {
+                        case "sole":
+                            context.report({
+                                data: { name },
+                                messageId: "sole",
+                                node: parserServices.tsNodeToESTreeNodeMap.get(res.soleUse),
+                            });
+                            break;
+                        case "never":
+                            context.report({
+                                data: { name },
+                                messageId: "never",
+                                node: parserServices.tsNodeToESTreeNodeMap.get(typeParameter),
+                            });
+                            break;
+                    }
+                }
+            },
+        };
+    },
+});
+function getSoleUse(sig, typeParameterSymbol, checker) {
+    const exit = {};
+    let soleUse;
+    try {
+        if (sig.typeParameters) {
+            for (const tp of sig.typeParameters) {
+                if (tp.constraint) {
+                    recur(tp.constraint);
+                }
+            }
+        }
+        for (const param of sig.parameters) {
+            if (param.type) {
+                recur(param.type);
+            }
+        }
+        if (sig.type) {
+            recur(sig.type);
+        }
+    }
+    catch (err) {
+        if (err === exit) {
+            return { type: "ok" };
+        }
+        throw err;
+    }
+    return soleUse ? { type: "sole", soleUse } : { type: "never" };
+    function recur(node) {
+        if (ts.isIdentifier(node)) {
+            if (checker.getSymbolAtLocation(node) === typeParameterSymbol) {
+                if (soleUse === undefined) {
+                    soleUse = node;
+                }
+                else {
+                    throw exit;
+                }
+            }
+        }
+        else {
+            node.forEachChild(recur);
+        }
+    }
+}
+function assertDefined(value) {
+    if (value === undefined) {
+        throw new Error("unreachable");
+    }
+    return value;
+}
+module.exports = rule;
+//# sourceMappingURL=no-unnecessary-generics.js.map

package/dist/rules/no-unnecessary-generics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unnecessary-generics.js","sourceRoot":"","sources":["../../src/rules/no-unnecessary-generics.ts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-declare-function.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from "@typescript-eslint/utils";
+declare const rule: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"variableFunction", never[], {
+    "VariableDeclaration > VariableDeclarator"(node: TSESTree.VariableDeclarator): void;
+}>;
+export = rule;

package/dist/rules/prefer-declare-function.js

@@ -0,0 +1,35 @@
+"use strict";
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const rule = (0, util_1.createRule)({
+    defaultOptions: [],
+    meta: {
+        docs: {
+            description: "Forbids `const x: () => void`.",
+            recommended: "error",
+        },
+        messages: {
+            variableFunction: "Use a function declaration instead of a variable of function type.",
+        },
+        schema: [],
+        type: "problem",
+    },
+    name: "prefer-declare-function",
+    create(context) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            "VariableDeclaration > VariableDeclarator"(node) {
+                var _a;
+                if (((_a = node.id.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeAnnotation.type) === utils_1.AST_NODE_TYPES.TSFunctionType &&
+                    context.getFilename().endsWith(".d.ts")) {
+                    context.report({
+                        messageId: "variableFunction",
+                        node: node.id,
+                    });
+                }
+            },
+        };
+    },
+});
+module.exports = rule;
+//# sourceMappingURL=prefer-declare-function.js.map

package/dist/rules/prefer-declare-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-declare-function.js","sourceRoot":"","sources":["../../src/rules/prefer-declare-function.ts"],"names":[],"mappings":";AAAA,oDAAoE;AAEpE,kCAAqC;AAErC,MAAM,IAAI,GAAG,IAAA,iBAAU,EAAC;IACtB,cAAc,EAAE,EAAE;IAClB,IAAI,EAAE;QACJ,IAAI,EAAE;YACJ,WAAW,EAAE,gCAAgC;YAC7C,WAAW,EAAE,OAAO;SACrB;QACD,QAAQ,EAAE;YACR,gBAAgB,EAAE,oEAAoE;SACvF;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,SAAS;KAChB;IACD,IAAI,EAAE,yBAAyB;IAC/B,MAAM,CAAC,OAAO;QACZ,OAAO;YACL,gEAAgE;YAChE,0CAA0C,CAAC,IAAiC;;gBAC1E,IACE,CAAA,MAAA,IAAI,CAAC,EAAE,CAAC,cAAc,0CAAE,cAAc,CAAC,IAAI,MAAK,sBAAc,CAAC,cAAc;oBAC7E,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,EACvC;oBACA,OAAO,CAAC,MAAM,CAAC;wBACb,SAAS,EAAE,kBAAkB;wBAC7B,IAAI,EAAE,IAAI,CAAC,EAAE;qBACd,CAAC,CAAC;iBACJ;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,iBAAS,IAAI,CAAC"}

package/dtslint.json

@@ -9,10 +9,7 @@
         "redundant-undefined": true,
         "no-relative-import-in-test": true,
         "strict-export-declare-modifiers": true,
-        "no-any-union": true,
         "no-single-declare-module": true,
-        "no-unnecessary-generics": true,
-        "prefer-declare-function": true,
         "unified-signatures": true,
         "void-return": true,
         "npm-naming": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@definitelytyped/dtslint",
-  "version": "0.0.141",
+  "version": "0.0.142-next.12",
   "description": "Runs tests on TypeScript definition files",
   "main": "./dist/index.js",
   "bin": "./dist/index.js",
@@ -44,11 +44,11 @@
     "@types/fs-extra": "^5.0.2",
     "@types/json-stable-stringify": "^1.0.32",
     "@types/strip-json-comments": "^0.0.28",
-    "typescript": "next"
+    "typescript": "4.7.4"
   },
   "engines": {
     "node": ">=10.0.0"
   },
   "license": "MIT",
-  "gitHead": "60e42f914dcfb07c5072de0c0aebaeac34b596e4"
+  "gitHead": "ada755591d9e6980cfdcb69ce9e2e7c740378384"
 }

package/src/rules/no-any-union.ts

@@ -0,0 +1,34 @@
+import { createRule } from "../util";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+const rule = createRule({
+  name: "no-any-union",
+  defaultOptions: [],
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid a union to contain `any`",
+      recommended: "error",
+    },
+    messages: {
+      anyUnion: "Including `any` in a union will override all other members of the union.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      TSUnionType(node) {
+        const hasAnyType = node.types.some((t) => t.type === AST_NODE_TYPES.TSAnyKeyword);
+        if (hasAnyType) {
+          context.report({
+            messageId: "anyUnion",
+            node,
+          });
+        }
+      },
+    };
+  },
+});
+
+export = rule;

package/src/rules/no-unnecessary-generics.ts

@@ -0,0 +1,126 @@
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+
+import { createRule } from "../util";
+
+type ESTreeFunctionLikeWithTypeParameters = TSESTree.FunctionLike & {
+  typeParameters: {};
+};
+
+type TSSignatureDeclarationWithTypeParameters = ts.SignatureDeclaration & {
+  typeParameters: {};
+};
+
+const rule = createRule({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids signatures using a generic parameter only once.",
+      recommended: "error",
+    },
+    messages: {
+      never: "Type parameter {{name}} is never used.",
+      sole: "Type parameter {{name}} is used only once.",
+    },
+    schema: [],
+    type: "problem",
+  },
+  name: "no-relative-import-in-test",
+  create(context) {
+    return {
+      [[
+        "ArrowFunctionExpression[typeParameters]",
+        "FunctionDeclaration[typeParameters]",
+        "FunctionExpression[typeParameters]",
+        "TSCallSignatureDeclaration[typeParameters]",
+        "TSConstructorType[typeParameters]",
+        "TSDeclareFunction[typeParameters]",
+        "TSFunctionType[typeParameters]",
+        "TSMethodSignature[typeParameters]",
+      ].join(", ")](esNode: ESTreeFunctionLikeWithTypeParameters) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(esNode) as TSSignatureDeclarationWithTypeParameters;
+        if (!tsNode.typeParameters) {
+          return;
+        }
+
+        const checker = parserServices.program.getTypeChecker();
+
+        for (const typeParameter of tsNode.typeParameters) {
+          const name = typeParameter.name.text;
+          const res = getSoleUse(tsNode, assertDefined(checker.getSymbolAtLocation(typeParameter.name)), checker);
+          switch (res.type) {
+            case "sole":
+              context.report({
+                data: { name },
+                messageId: "sole",
+                node: parserServices.tsNodeToESTreeNodeMap.get(res.soleUse),
+              });
+              break;
+            case "never":
+              context.report({
+                data: { name },
+                messageId: "never",
+                node: parserServices.tsNodeToESTreeNodeMap.get(typeParameter),
+              });
+              break;
+          }
+        }
+      },
+    };
+  },
+});
+
+type Result = { type: "ok" | "never" } | { type: "sole"; soleUse: ts.Identifier };
+function getSoleUse(sig: ts.SignatureDeclaration, typeParameterSymbol: ts.Symbol, checker: ts.TypeChecker): Result {
+  const exit = {};
+  let soleUse: ts.Identifier | undefined;
+
+  try {
+    if (sig.typeParameters) {
+      for (const tp of sig.typeParameters) {
+        if (tp.constraint) {
+          recur(tp.constraint);
+        }
+      }
+    }
+    for (const param of sig.parameters) {
+      if (param.type) {
+        recur(param.type);
+      }
+    }
+    if (sig.type) {
+      recur(sig.type);
+    }
+  } catch (err) {
+    if (err === exit) {
+      return { type: "ok" };
+    }
+    throw err;
+  }
+
+  return soleUse ? { type: "sole", soleUse } : { type: "never" };
+
+  function recur(node: ts.Node): void {
+    if (ts.isIdentifier(node)) {
+      if (checker.getSymbolAtLocation(node) === typeParameterSymbol) {
+        if (soleUse === undefined) {
+          soleUse = node;
+        } else {
+          throw exit;
+        }
+      }
+    } else {
+      node.forEachChild(recur);
+    }
+  }
+}
+
+export = rule;
+
+function assertDefined<T>(value: T | undefined): T {
+  if (value === undefined) {
+    throw new Error("unreachable");
+  }
+  return value;
+}

package/src/rules/prefer-declare-function.ts

@@ -0,0 +1,37 @@
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
+
+import { createRule } from "../util";
+
+const rule = createRule({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbids `const x: () => void`.",
+      recommended: "error",
+    },
+    messages: {
+      variableFunction: "Use a function declaration instead of a variable of function type.",
+    },
+    schema: [],
+    type: "problem",
+  },
+  name: "prefer-declare-function",
+  create(context) {
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      "VariableDeclaration > VariableDeclarator"(node: TSESTree.VariableDeclarator) {
+        if (
+          node.id.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES.TSFunctionType &&
+          context.getFilename().endsWith(".d.ts")
+        ) {
+          context.report({
+            messageId: "variableFunction",
+            node: node.id,
+          });
+        }
+      },
+    };
+  },
+});
+
+export = rule;

package/test/no-any-union.test.ts

@@ -0,0 +1,22 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noAnyUnion from "../src/rules/no-any-union";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("no-any-union", noAnyUnion, {
+  invalid: [
+    {
+      code: `export const y: string | any;`,
+      errors: [
+        {
+          line: 1,
+          messageId: "anyUnion",
+        },
+      ],
+    },
+  ],
+  valid: [`export const x: any;`],
+});

package/test/no-unnecessary-generics.test.ts

@@ -0,0 +1,152 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as rule from "../src/rules/no-unnecessary-generics";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parserOptions: {
+    ecmaVersion: 2018,
+    tsconfigRootDir: __dirname,
+    project: "./tsconfig.json",
+  },
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("no-unnecessary-generics", rule, {
+  invalid: [
+    {
+      code: `
+const f2 = <T>(): T => {};
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 19,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+class C {
+  constructor<T>(x: T) {}
+}
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 21,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+function f<T>(): T { }
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 18,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+function f<T>(x: { T: number }): void;
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 12,
+          messageId: "never",
+        },
+      ],
+    },
+    {
+      code: `
+function f<T, U extends T>(u: U): U;
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 25,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+const f = function<T>(): T {};
+      `,
+      errors: [
+        {
+          line: 2,
+          column: 26,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+interface I {
+  <T>(value: T): void;
+}
+      `,
+      errors: [
+        {
+          line: 3,
+          column: 14,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+interface I {
+  m<T>(x: T): void;
+}
+  `,
+      errors: [
+        {
+          line: 3,
+          column: 11,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+type Fn = <T>() => T;
+  `,
+      errors: [
+        {
+          line: 2,
+          column: 20,
+          messageId: "sole",
+        },
+      ],
+    },
+    {
+      code: `
+type Ctr = new<T>() => T;
+  `,
+      errors: [
+        {
+          line: 2,
+          column: 24,
+          messageId: "sole",
+        },
+      ],
+    },
+  ],
+  valid: [
+    `function example(a: string): string;`,
+    `function example<T>(a: T): T;`,
+    `function example<T>(a: T[]): T;`,
+    `function example<T>(a: Set<T>): T;`,
+    `function example<T>(a: Set<T>, b: T[]): void;`,
+    `function example<T>(a: Map<T, T>): void;`,
+    `function example<T, U extends T>(t: T, u: U): U;`,
+  ],
+});