@definitelytyped/dtslint 0.0.141 → 0.0.142-next.10

package/src/rules/noUnnecessaryGenericsRule.ts

@@ -1,115 +0,0 @@
-import * as Lint from "tslint";
-import * as ts from "typescript";
-
-import { failure } from "../util";
-
-export class Rule extends Lint.Rules.TypedRule {
-  static metadata: Lint.IRuleMetadata = {
-    ruleName: "no-unnecessary-generics",
-    description: "Forbids signatures using a generic parameter only once.",
-    optionsDescription: "Not configurable.",
-    options: null,
-    type: "style",
-    typescriptOnly: true,
-  };
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  static FAILURE_STRING(typeParameter: string) {
-    return failure(Rule.metadata.ruleName, `Type parameter ${typeParameter} is used only once.`);
-  }
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  static FAILURE_STRING_NEVER(typeParameter: string) {
-    return failure(Rule.metadata.ruleName, `Type parameter ${typeParameter} is never used.`);
-  }
-
-  applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-    return this.applyWithFunction(sourceFile, (ctx) => walk(ctx, program.getTypeChecker()));
-  }
-}
-
-function walk(ctx: Lint.WalkContext<void>, checker: ts.TypeChecker): void {
-  const { sourceFile } = ctx;
-  sourceFile.forEachChild(function cb(node) {
-    if (ts.isFunctionLike(node)) {
-      checkSignature(node);
-    }
-    node.forEachChild(cb);
-  });
-
-  function checkSignature(sig: ts.SignatureDeclaration) {
-    if (!sig.typeParameters) {
-      return;
-    }
-
-    for (const tp of sig.typeParameters) {
-      const typeParameter = tp.name.text;
-      const res = getSoleUse(sig, assertDefined(checker.getSymbolAtLocation(tp.name)), checker);
-      switch (res.type) {
-        case "ok":
-          break;
-        case "sole":
-          ctx.addFailureAtNode(res.soleUse, Rule.FAILURE_STRING(typeParameter));
-          break;
-        case "never":
-          ctx.addFailureAtNode(tp, Rule.FAILURE_STRING_NEVER(typeParameter));
-          break;
-        default:
-          assertNever(res);
-      }
-    }
-  }
-}
-
-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);
-    }
-  }
-}
-
-function assertDefined<T>(value: T | undefined): T {
-  if (value === undefined) {
-    throw new Error("unreachable");
-  }
-  return value;
-}
-function assertNever(_: never) {
-  throw new Error("unreachable");
-}

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

@@ -1,4 +0,0 @@
-export const x: any;
-
-export const y: string | any;
-                         ~~~  [Including `any` in a union will override all other members of the union. See: https://github.com/microsoft/DefinitelyTyped-tools/blob/master/packages/dtslint/docs/no-any-union.md]

package/test/no-any-union/tslint.json

@@ -1,6 +0,0 @@
-{
-    "rulesDirectory": ["../../dist/rules"],
-    "rules": {
-      "no-any-union": true
-    }
-  }

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

@@ -1,38 +0,0 @@
-interface I {
-    <T>(value: T): void;
-               ~ [0]
-    m<T>(x: T): void;
-            ~ [0]
-}
-
-class C {
-    constructor<T>(x: T) {}
-                      ~ [0]
-}
-
-type Fn = <T>() => T;
-                   ~ [0]
-type Ctr = new<T>() => T;
-                       ~ [0]
-
-function f<T>(): T { }
-                 ~ [0]
-
-const f = function<T>(): T {};
-                         ~ [0]
-const f2 = <T>(): T => {};
-                  ~ [0]
-
-function f<T>(x: { T: number }): void;
-           ~ [Type parameter T is never used. See: https://github.com/microsoft/DefinitelyTyped-tools/blob/master/packages/dtslint/docs/no-unnecessary-generics.md]
-
-function f<T, U extends T>(u: U): U;
-                        ~ [0]
-
-// OK:
-// Uses type parameter twice
-function foo<T>(m: Map<T, T>): void {}
-// `T` appears in a constraint, so it appears twice.
-function f<T, U extends T>(t: T, u: U): U;
-
-[0]: Type parameter T is used only once. See: https://github.com/microsoft/DefinitelyTyped-tools/blob/master/packages/dtslint/docs/no-unnecessary-generics.md

package/test/no-unnecessary-generics/tsconfig.json

@@ -1 +0,0 @@
-{}

package/test/no-unnecessary-generics/tslint.json

@@ -1,6 +0,0 @@
-{
-    "rulesDirectory": ["../../dist/rules"],
-    "rules": {
-        "no-unnecessary-generics": true
-    }
-}