@definitelytyped/eslint-plugin 0.0.166-next.4

package/src/rules/no-self-import.ts

@@ -0,0 +1,40 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { createRule, getCommonDirectoryName } from "../util";
+
+const rule = createRule({
+  name: "no-self-import",
+  defaultOptions: [],
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids declaration files to import the current package using a global import.",
+      recommended: "error",
+    },
+    messages: {
+      useRelativeImport: "Declaration file should not use a global import of itself. Use a relative import.",
+    },
+    schema: [],
+  },
+  create(context) {
+    if (!context.getFilename().endsWith(".d.ts")) {
+      return {};
+    }
+
+    const services = ESLintUtils.getParserServices(context);
+    const packageName = getCommonDirectoryName(services.program.getRootFileNames());
+
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      ImportDeclaration(node) {
+        if (node.source.value === packageName || node.source.value.startsWith(packageName + "/")) {
+          context.report({
+            messageId: "useRelativeImport",
+            node,
+          });
+        }
+      },
+    };
+  },
+});
+
+export = rule;

package/src/rules/no-single-element-tuple-type.ts

@@ -0,0 +1,31 @@
+import { createRule } from "../util";
+import { TSESTree } from "@typescript-eslint/utils";
+
+const rule = createRule({
+  name: "no-single-element-tuple-type",
+  defaultOptions: [],
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids `[T]`, which should be `T[]`.",
+      recommended: "error",
+    },
+    messages: {
+      singleElementTupleType: `Type [T] is a single-element tuple type. You probably meant T[].`,
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      "TSTupleType[elementTypes.length=1]"(node: TSESTree.TSTupleType) {
+        context.report({
+          messageId: "singleElementTupleType",
+          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/no-useless-files.ts

@@ -0,0 +1,58 @@
+import { createRule } from "../util";
+
+const rule = createRule({
+  name: "no-useless-files",
+  defaultOptions: [],
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids files with no content.",
+      recommended: "error",
+    },
+    messages: {
+      noContent: "File has no content.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const {
+      ast: { tokens, comments },
+    } = context.getSourceCode();
+
+    if (tokens.length === 0) {
+      if (comments.length === 0) {
+        reportNoContent();
+      } else {
+        const referenceRegExp = /^\/\s*<reference\s*(types|path)\s*=\s*["|'](.*)["|']/;
+        let noReferenceFound = true;
+
+        for (const comment of comments) {
+          const referenceMatch = comment.value.match(referenceRegExp)?.[1];
+          if (!referenceMatch) {
+            continue;
+          }
+          noReferenceFound = false;
+          break;
+        }
+
+        if (noReferenceFound) {
+          reportNoContent();
+        }
+      }
+    }
+
+    return {};
+
+    function reportNoContent() {
+      context.report({
+        messageId: "noContent",
+        loc: {
+          start: { line: 1, column: 0 },
+          end: { line: 1, column: 0 },
+        },
+      });
+    }
+  },
+});
+
+export = rule;

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/src/rules/redundant-undefined.ts

@@ -0,0 +1,62 @@
+import { createRule } from "../util";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { TSESTree } from "@typescript-eslint/types";
+
+const rule = createRule({
+  name: "redundant-undefined",
+  defaultOptions: [],
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Forbids optional parameters from including an explicit `undefined` in their type; requires it in optional properties.",
+      recommended: "error",
+    },
+    messages: {
+      redundantUndefined: `Parameter is optional, so no need to include \`undefined\` in the type.`,
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      TSUnionType(node) {
+        const hasUndefinedType = node.types.some((t) => t.type === AST_NODE_TYPES.TSUndefinedKeyword);
+        if (
+          node.parent!.type === AST_NODE_TYPES.TSTypeAnnotation &&
+          isParameter(node.parent!.parent!) &&
+          node.parent.parent.optional &&
+          isFunctionLike(node.parent!.parent!.parent!) &&
+          hasUndefinedType
+        ) {
+          context.report({
+            messageId: "redundantUndefined",
+            node,
+          });
+        }
+      },
+    };
+  },
+});
+
+function isFunctionLike(node: TSESTree.Node): node is TSESTree.FunctionLike {
+  return (
+    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === AST_NODE_TYPES.FunctionDeclaration ||
+    node.type === AST_NODE_TYPES.FunctionExpression ||
+    node.type === AST_NODE_TYPES.TSDeclareFunction ||
+    node.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression
+  );
+}
+/** Note: Does not include parameter properties because those can't be optional */
+function isParameter(node: TSESTree.Node): node is Exclude<TSESTree.Parameter, TSESTree.TSParameterProperty> {
+  return (
+    node.type === AST_NODE_TYPES.ArrayPattern ||
+    node.type === AST_NODE_TYPES.AssignmentPattern ||
+    node.type === AST_NODE_TYPES.Identifier ||
+    node.type === AST_NODE_TYPES.ObjectPattern ||
+    node.type === AST_NODE_TYPES.RestElement
+  );
+}
+
+export = rule;

package/src/rules/trim-file.ts

@@ -0,0 +1,45 @@
+import { createRule } from "../util";
+
+const rule = createRule({
+  name: "trim-file",
+  defaultOptions: [],
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Forbids leading/trailing blank lines in a file. Allows file to end in '\n'",
+      recommended: "error",
+    },
+    messages: {
+      leadingBlankLine: "File should not begin with a blank line.",
+      trailingBlankLine:
+        "File should not end with a blank line. (Ending in one newline OK, ending in two newlines not OK.)",
+    },
+    schema: [],
+  },
+  create(context) {
+    const { lines, text } = context.getSourceCode();
+    if (text.startsWith("\r") || text.startsWith("\n")) {
+      context.report({
+        messageId: "leadingBlankLine",
+        loc: {
+          start: { line: 1, column: 0 },
+          end: { line: 1, column: 0 },
+        },
+      });
+    }
+    if (text.endsWith("\n\n") || text.endsWith("\r\n\r\n")) {
+      const line = lines.length;
+      context.report({
+        messageId: "trailingBlankLine",
+        loc: {
+          start: { line, column: 0 },
+          end: { line, column: 0 },
+        },
+      });
+    }
+
+    return {};
+  },
+});
+
+export = rule;

package/src/util.ts

@@ -0,0 +1,41 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { basename, dirname } from "path";
+
+export const createRule = ESLintUtils.RuleCreator(
+  (name) =>
+    `https://github.com/microsoft/DefinitelyTyped-tools/tree/master/packages/eslint-plugin/docs/rules/${name}.md`
+);
+
+export function getCommonDirectoryName(files: readonly string[]): string {
+  let minLen = 999;
+  let minDir = "";
+  for (const file of files) {
+    const dir = dirname(file);
+    if (dir.length < minLen) {
+      minDir = dir;
+      minLen = dir.length;
+    }
+  }
+  return basename(minDir);
+}
+
+export function isMainFile(fileName: string, allowNested: boolean) {
+  // Linter may be run with cwd of the package. We want `index.d.ts` but not `submodule/index.d.ts` to match.
+  if (fileName === "index.d.ts") {
+    return true;
+  }
+
+  if (basename(fileName) !== "index.d.ts") {
+    return false;
+  }
+
+  let parent = dirname(fileName);
+  // May be a directory for an older version, e.g. `v0`.
+  // Note a types redirect `foo/ts3.1` should not have its own header.
+  if (allowNested && /^v(0\.)?\d+$/.test(basename(parent))) {
+    parent = dirname(parent);
+  }
+
+  // Allow "types/foo/index.d.ts", not "types/foo/utils/index.d.ts"
+  return basename(dirname(parent)) === "types";
+}

package/test/dt-header.test.ts

@@ -0,0 +1,189 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as dtHeader from "../src/rules/dt-header";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/dt-header", dtHeader, {
+  invalid: [
+    {
+      code: ``,
+      errors: [
+        {
+          column: 2,
+          data: {
+            expected: "/\\/\\/ Type definitions for (non-npm package )?/",
+          },
+          line: 1,
+          messageId: "parseError",
+        },
+      ],
+      filename: "types/blank/index.d.ts",
+    },
+    {
+      code: `
+      // ...
+      `,
+      errors: [
+        {
+          column: 1,
+          data: {
+            expected: "/\\/\\/ Type definitions for (non-npm package )?/",
+          },
+          line: 2,
+          messageId: "parseError",
+        },
+      ],
+      filename: "types/only-comment/index.d.ts",
+    },
+    {
+      code: `
+// Type definitions for dt-header 0.75
+// Project: https://github.com/bobby-headers/dt-header
+// Definitions by: Jane Doe <https://github.com/janedoe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.1
+      
+`,
+      errors: [
+        {
+          column: 1,
+          data: {
+            expected: "/\\/\\/ Type definitions for (non-npm package )?/",
+          },
+          line: 2,
+          messageId: "parseError",
+        },
+      ],
+      filename: "types/start-with-whitespace/index.d.ts",
+    },
+    {
+      code: `// Type definitions for dt-header 1.0
+// Project: https://github.com/bobby-headers/dt-header
+// Definitions by: Jane Doe <https://github.ORG/janedoe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+`,
+      errors: [
+        {
+          column: 30,
+          data: {
+            expected: "/\\<https\\:\\/\\/github\\.com\\/([a-zA-Z\\d\\-]+)\\/?\\>/",
+          },
+          line: 3,
+          messageId: "parseError",
+        },
+      ],
+      filename: "types/bad-url-github-org/index.d.ts",
+    },
+    {
+      code: `// Type definitions for dt-header 1.0
+// Project: https://github.com/bobby-headers/dt-header
+// Definitions by: Jane Doe <https://github.com/jane doe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+`,
+      errors: [
+        {
+          column: 30,
+          data: {
+            expected: "/\\<https\\:\\/\\/github\\.com\\/([a-zA-Z\\d\\-]+)\\/?\\>/",
+          },
+          line: 3,
+          messageId: "parseError",
+        },
+      ],
+      filename: "types/bad-url-space/index.d.ts",
+    },
+    {
+      code: `// Type definitions for dt-header 1.0
+// Project: https://github.com/not/important
+// Definitions by: My Self <https://github.com/me>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+      
+`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 27,
+          line: 3,
+          messageId: "definitionsBy",
+        },
+      ],
+      filename: "types/bad-username/index.d.ts",
+    },
+    {
+      code: `// Type definitions for dt-header v1.0.3
+// Project: https://github.com/bobby-headers/dt-header
+// Definitions by: Jane Doe <https://github.com/janedoe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+`,
+      errors: [
+        {
+          column: 26,
+          data: {
+            expected: "foo MAJOR.MINOR (patch version not allowed)",
+          },
+          line: 1,
+          messageId: "parseError",
+        },
+      ],
+      filename: "types/foo/index.d.ts",
+    },
+    {
+      code: `// Type definitions for
+`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 24,
+          line: 1,
+          messageId: "typeDefinitionsFor",
+        },
+      ],
+      filename: "types/foo/notIndex.d.ts",
+    },
+  ],
+  valid: [
+    ``,
+    {
+      code: `// This isn't the main index
+`,
+      filename: "types/foo/bar/index.d.ts",
+    },
+    {
+      code: `// Type definitions for dt-header 0.75
+// Project: https://github.com/bobby-headers/dt-header
+// Definitions by: Jane Doe <https://github.com/janedoe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.1
+      
+`,
+      filename: "types/foo/v0.75/index.d.ts",
+    },
+    {
+      code: `// Type definitions for dt-header 1.0
+// Project: https://github.com/bobby-headers/dt-header
+// Definitions by: Jane Doe <https://github.com/janedoe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.1
+      
+`,
+      filename: "types/foo/v1/index.d.ts",
+    },
+    {
+      code: `// Type definitions for dt-header 2.0
+// Project: https://github.com/bobby-headers/dt-header
+// Definitions by: Jane Doe <https://github.com/janedoe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.1
+      
+`,
+      filename: "types/foo/index.d.ts",
+    },
+    {
+      code: ``,
+      filename: "types/foo/notIndex.d.ts",
+    },
+  ],
+});

package/test/export-just-namespace.test.ts

@@ -0,0 +1,70 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as exportJustNamespace from "../src/rules/export-just-namespace";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/export-just-namespace", exportJustNamespace, {
+  invalid: [
+    {
+      code: `
+export = Stuff;
+namespace Stuff {}
+`,
+      errors: [
+        {
+          line: 2,
+          messageId: "useTheBody",
+        },
+      ],
+    },
+    {
+      code: `
+namespace Stuff {}
+export = Stuff;
+`,
+      errors: [
+        {
+          line: 3,
+          messageId: "useTheBody",
+        },
+      ],
+    },
+    {
+      code: `
+namespace Stuff {}
+const other = "code";
+export = Stuff;
+`,
+      errors: [
+        {
+          line: 4,
+          messageId: "useTheBody",
+        },
+      ],
+    },
+  ],
+  valid: [
+    `export const value = 3;`,
+    `export default class Hello {}`,
+    'import * as fs from "fs";',
+    "const value = 123;",
+    `export = stuff;`,
+    `export = createStuff();`,
+    `
+class Stuff {}
+namespace Stuff {}
+export = Stuff;
+`,
+    `export = First
+namespace First {}
+declare function First()
+`,
+    `declare namespace Second {}
+export = Second
+declare function Second<U, S>(s: U): S
+`,
+  ],
+});