@definitelytyped/dtslint 0.0.141 → 0.0.142-next.12

package/dist/rules/preferDeclareFunctionRule.js

@@ -1,56 +0,0 @@
-"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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rule = void 0;
-const Lint = __importStar(require("tslint"));
-const ts = __importStar(require("typescript"));
-const util_1 = require("../util");
-class Rule extends Lint.Rules.AbstractRule {
-    apply(sourceFile) {
-        return this.applyWithFunction(sourceFile, walk);
-    }
-}
-exports.Rule = Rule;
-Rule.metadata = {
-    ruleName: "prefer-declare-function",
-    description: "Forbids `export const x = () => void`.",
-    optionsDescription: "Not configurable.",
-    options: null,
-    type: "style",
-    typescriptOnly: true,
-};
-Rule.FAILURE_STRING = (0, util_1.failure)(Rule.metadata.ruleName, "Use a function declaration instead of a variable of function type.");
-function walk(ctx) {
-    (0, util_1.eachModuleStatement)(ctx.sourceFile, (statement) => {
-        if (ts.isVariableStatement(statement)) {
-            for (const varDecl of statement.declarationList.declarations) {
-                if (varDecl.type !== undefined && varDecl.type.kind === ts.SyntaxKind.FunctionType) {
-                    ctx.addFailureAtNode(varDecl, Rule.FAILURE_STRING);
-                }
-            }
-        }
-    });
-}
-//# sourceMappingURL=preferDeclareFunctionRule.js.map

package/dist/rules/preferDeclareFunctionRule.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"preferDeclareFunctionRule.js","sourceRoot":"","sources":["../../src/rules/preferDeclareFunctionRule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAA+B;AAC/B,+CAAiC;AAEjC,kCAAuD;AAEvD,MAAa,IAAK,SAAQ,IAAI,CAAC,KAAK,CAAC,YAAY;IAe/C,KAAK,CAAC,UAAyB;QAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAClD,CAAC;;AAjBH,oBAkBC;AAjBQ,aAAQ,GAAuB;IACpC,QAAQ,EAAE,yBAAyB;IACnC,WAAW,EAAE,wCAAwC;IACrD,kBAAkB,EAAE,mBAAmB;IACvC,OAAO,EAAE,IAAI;IACb,IAAI,EAAE,OAAO;IACb,cAAc,EAAE,IAAI;CACrB,CAAC;AAEK,mBAAc,GAAG,IAAA,cAAO,EAC7B,IAAI,CAAC,QAAQ,CAAC,QAAQ,EACtB,oEAAoE,CACrE,CAAC;AAOJ,SAAS,IAAI,CAAC,GAA2B;IACvC,IAAA,0BAAmB,EAAC,GAAG,CAAC,UAAU,EAAE,CAAC,SAAS,EAAE,EAAE;QAChD,IAAI,EAAE,CAAC,mBAAmB,CAAC,SAAS,CAAC,EAAE;YACrC,KAAK,MAAM,OAAO,IAAI,SAAS,CAAC,eAAe,CAAC,YAAY,EAAE;gBAC5D,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,EAAE;oBAClF,GAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;iBACpD;aACF;SACF;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/src/rules/noAnyUnionRule.ts

@@ -1,33 +0,0 @@
-import * as Lint from "tslint";
-import * as ts from "typescript";
-
-import { failure } from "../util";
-
-export class Rule extends Lint.Rules.AbstractRule {
-  static metadata: Lint.IRuleMetadata = {
-    ruleName: "no-any-union",
-    description: "Forbid a union to contain `any`",
-    optionsDescription: "Not configurable.",
-    options: null,
-    type: "functionality",
-    typescriptOnly: true,
-  };
-
-  static FAILURE_STRING = failure(
-    Rule.metadata.ruleName,
-    "Including `any` in a union will override all other members of the union."
-  );
-
-  apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-    return this.applyWithFunction(sourceFile, walk);
-  }
-}
-
-function walk(ctx: Lint.WalkContext<void>): void {
-  ctx.sourceFile.forEachChild(function recur(node) {
-    if (node.kind === ts.SyntaxKind.AnyKeyword && ts.isUnionTypeNode(node.parent!)) {
-      ctx.addFailureAtNode(node, Rule.FAILURE_STRING);
-    }
-    node.forEachChild(recur);
-  });
-}

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

@@ -1,36 +0,0 @@
-import * as Lint from "tslint";
-import * as ts from "typescript";
-
-import { eachModuleStatement, failure } from "../util";
-
-export class Rule extends Lint.Rules.AbstractRule {
-  static metadata: Lint.IRuleMetadata = {
-    ruleName: "prefer-declare-function",
-    description: "Forbids `export const x = () => void`.",
-    optionsDescription: "Not configurable.",
-    options: null,
-    type: "style",
-    typescriptOnly: true,
-  };
-
-  static FAILURE_STRING = failure(
-    Rule.metadata.ruleName,
-    "Use a function declaration instead of a variable of function type."
-  );
-
-  apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-    return this.applyWithFunction(sourceFile, walk);
-  }
-}
-
-function walk(ctx: Lint.WalkContext<void>): void {
-  eachModuleStatement(ctx.sourceFile, (statement) => {
-    if (ts.isVariableStatement(statement)) {
-      for (const varDecl of statement.declarationList.declarations) {
-        if (varDecl.type !== undefined && varDecl.type.kind === ts.SyntaxKind.FunctionType) {
-          ctx.addFailureAtNode(varDecl, Rule.FAILURE_STRING);
-        }
-      }
-    }
-  });
-}

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
-    }
-}

package/test/prefer-declare-function/test.d.ts.lint

@@ -1,10 +0,0 @@
-export const x: () => void;
-             ~~~~~~~~~~~~~ [0]
-
-namespace N {
-    const x: () => void;
-          ~~~~~~~~~~~~~ [0]
-}
-
-
-[0]: Use a function declaration instead of a variable of function type. See: https://github.com/microsoft/DefinitelyTyped-tools/blob/master/packages/dtslint/docs/prefer-declare-function.md

package/test/prefer-declare-function/tslint.json

@@ -1,6 +0,0 @@
-{
-  "rulesDirectory": ["../../dist/rules"],
-  "rules": {
-    "prefer-declare-function": true
-  }
-}