diff options
Diffstat (limited to 'node_modules/tslint/lib/language')
10 files changed, 126 insertions, 32 deletions
diff --git a/node_modules/tslint/lib/language/rule/abstractRule.d.ts b/node_modules/tslint/lib/language/rule/abstractRule.d.ts index a5c2b82ac..65ed4a1b9 100644 --- a/node_modules/tslint/lib/language/rule/abstractRule.d.ts +++ b/node_modules/tslint/lib/language/rule/abstractRule.d.ts @@ -21,7 +21,7 @@ export declare type NoInfer<T> = T & { [K in keyof T]: T[K]; }; export declare abstract class AbstractRule implements IRule { - private options; + private readonly options; static metadata: IRuleMetadata; protected readonly ruleArguments: any[]; protected readonly ruleSeverity: RuleSeverity; diff --git a/node_modules/tslint/lib/language/rule/rule.d.ts b/node_modules/tslint/lib/language/rule/rule.d.ts index d1ba8ac58..e37861c36 100644 --- a/node_modules/tslint/lib/language/rule/rule.d.ts +++ b/node_modules/tslint/lib/language/rule/rule.d.ts @@ -73,9 +73,19 @@ export interface IRuleMetadata { * Whether or not the rule use for TypeScript only. If `false`, this rule may be used with .js files. */ typescriptOnly: boolean; + /** + * Examples demonstrating what the lint rule will pass and fail + */ + codeExamples?: ICodeExample[]; } export declare type RuleType = "functionality" | "maintainability" | "style" | "typescript"; export declare type RuleSeverity = "warning" | "error" | "off"; +export interface ICodeExample { + config: string; + description: string; + pass: string; + fail?: string; +} export interface IOptions { ruleArguments: any[]; ruleSeverity: RuleSeverity; @@ -141,8 +151,8 @@ export declare class Replacement { toJson(): ReplacementJson; } export declare class RuleFailurePosition { - private position; - private lineAndCharacter; + private readonly position; + private readonly lineAndCharacter; constructor(position: number, lineAndCharacter: ts.LineAndCharacter); getPosition(): number; getLineAndCharacter(): ts.LineAndCharacter; @@ -152,14 +162,14 @@ export declare class RuleFailurePosition { export declare type Fix = Replacement | Replacement[]; export declare type FixJson = ReplacementJson | ReplacementJson[]; export declare class RuleFailure { - private sourceFile; - private failure; - private ruleName; - private fix; - private fileName; - private startPosition; - private endPosition; - private rawLines; + private readonly sourceFile; + private readonly failure; + private readonly ruleName; + private readonly fix?; + private readonly fileName; + private readonly startPosition; + private readonly endPosition; + private readonly rawLines; private ruleSeverity; static compare(a: RuleFailure, b: RuleFailure): number; constructor(sourceFile: ts.SourceFile, start: number, end: number, failure: string, ruleName: string, fix?: Replacement | Replacement[] | undefined); @@ -175,5 +185,5 @@ export declare class RuleFailure { setRuleSeverity(value: RuleSeverity): void; toJson(): IRuleFailureJson; equals(ruleFailure: RuleFailure): boolean; - private createFailurePosition(position); + private createFailurePosition; } diff --git a/node_modules/tslint/lib/language/utils.d.ts b/node_modules/tslint/lib/language/utils.d.ts index ffdd0aabc..40b4aee16 100644 --- a/node_modules/tslint/lib/language/utils.d.ts +++ b/node_modules/tslint/lib/language/utils.d.ts @@ -1,3 +1,19 @@ +/** + * @license + * Copyright 2013 Palantir Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ import * as ts from "typescript"; import { IDisabledInterval, RuleFailure } from "./rule/rule"; export declare function getSourceFile(fileName: string, source: string): ts.SourceFile; @@ -5,59 +21,86 @@ export declare function getSourceFile(fileName: string, source: string): ts.Sour export declare function doesIntersect(failure: RuleFailure, disabledIntervals: IDisabledInterval[]): boolean; /** * @returns true if any modifier kinds passed along exist in the given modifiers array + * + * @deprecated use `hasModifier` from `tsutils` */ export declare function hasModifier(modifiers: ts.ModifiersArray | undefined, ...modifierKinds: ts.SyntaxKind[]): boolean; /** * Determines if the appropriate bit in the parent (VariableDeclarationList) is set, * which indicates this is a "let" or "const". + * + * @deprecated use `isBlockScopedVariableDeclarationList` from `tsutils` */ export declare function isBlockScopedVariable(node: ts.VariableDeclaration | ts.VariableStatement): boolean; +/** @deprecated use `isBlockScopedVariableDeclarationList` and `getDeclarationOfBindingElement` from `tsutils` */ export declare function isBlockScopedBindingElement(node: ts.BindingElement): boolean; +/** @deprecated use `getDeclarationOfBindingElement` from `tsutils` */ export declare function getBindingElementVariableDeclaration(node: ts.BindingElement): ts.VariableDeclaration | null; /** * Finds a child of a given node with a given kind. * Note: This uses `node.getChildren()`, which does extra parsing work to include tokens. + * + * @deprecated use `getChildOfKind` from `tsutils` */ export declare function childOfKind(node: ts.Node, kind: ts.SyntaxKind): ts.Node | undefined; /** * @returns true if some ancestor of `node` satisfies `predicate`, including `node` itself. + * + * @deprecated no longer used, use a `while` loop instead */ export declare function someAncestor(node: ts.Node, predicate: (n: ts.Node) => boolean): boolean; -export declare function ancestorWhere<T extends ts.Node>(node: ts.Node, predicate: (n: ts.Node) => n is T): T | undefined; -export declare function ancestorWhere(node: ts.Node, predicate: (n: ts.Node) => boolean): ts.Node | undefined; +export declare function ancestorWhere<T extends ts.Node = ts.Node>(node: ts.Node, predicate: ((n: ts.Node) => n is T) | ((n: ts.Node) => boolean)): T | undefined; +/** @deprecated use `isBinaryExpression(node) && isAssignmentKind(node.operatorToken.kind)` with functions from `tsutils` */ export declare function isAssignment(node: ts.Node): boolean; /** * Bitwise check for node flags. + * + * @deprecated use `isNodeFlagSet` from `tsutils` */ export declare function isNodeFlagSet(node: ts.Node, flagToCheck: ts.NodeFlags): boolean; /** * Bitwise check for combined node flags. + * + * @deprecated no longer used */ export declare function isCombinedNodeFlagSet(node: ts.Node, flagToCheck: ts.NodeFlags): boolean; /** * Bitwise check for combined modifier flags. + * + * @deprecated no longer used */ export declare function isCombinedModifierFlagSet(node: ts.Node, flagToCheck: ts.ModifierFlags): boolean; /** * Bitwise check for type flags. + * + * @deprecated use `isTypeFlagSet` from `tsutils` */ export declare function isTypeFlagSet(type: ts.Type, flagToCheck: ts.TypeFlags): boolean; /** * Bitwise check for symbol flags. + * + * @deprecated use `isSymbolFlagSet` from `tsutils` */ export declare function isSymbolFlagSet(symbol: ts.Symbol, flagToCheck: ts.SymbolFlags): boolean; /** * Bitwise check for object flags. * Does not work with TypeScript 2.0.x + * + * @deprecated use `isObjectFlagSet` from `tsutils` */ export declare function isObjectFlagSet(objectType: ts.ObjectType, flagToCheck: ts.ObjectFlags): boolean; /** * @returns true if decl is a nested module declaration, i.e. represents a segment of a dotted module path. + * + * @deprecated use `decl.parent!.kind === ts.SyntaxKind.ModuleDeclaration` */ export declare function isNestedModuleDeclaration(decl: ts.ModuleDeclaration): boolean; export declare function unwrapParentheses(node: ts.Expression): ts.Expression; +/** @deprecated use `isFunctionScopeBoundary` from `tsutils` */ export declare function isScopeBoundary(node: ts.Node): boolean; +/** @deprecated use `isBlockScopeBoundary` from `tsutils` */ export declare function isBlockScopeBoundary(node: ts.Node): boolean; +/** @deprecated use `isIterationStatement` from `tsutils` or `typescript` */ export declare function isLoop(node: ts.Node): node is ts.IterationStatement; /** * @returns Whether node is a numeric expression. @@ -83,9 +126,15 @@ export declare type FilterCallback = (node: ts.Node) => boolean; * @param skipTrivia If set to false all trivia preceeding `node` or any of its children is included * @param cb Is called for every token of `node`. It gets the full text of the SourceFile and the position of the token within that text. * @param filter If provided, will be called for every Node and Token found. If it returns false `cb` will not be called for this subtree. + * + * @deprecated use `forEachToken` or `forEachTokenWithTrivia` from `tsutils` */ export declare function forEachToken(node: ts.Node, skipTrivia: boolean, cb: ForEachTokenCallback, filter?: FilterCallback): void; -/** Iterate over all comments owned by `node` or its children */ +/** + * Iterate over all comments owned by `node` or its children + * + * @deprecated use `forEachComment` from `tsutils` + */ export declare function forEachComment(node: ts.Node, cb: ForEachCommentCallback): void; /** * Checks if there are any comments between `position` and the next non-trivia token diff --git a/node_modules/tslint/lib/language/utils.js b/node_modules/tslint/lib/language/utils.js index e9ba81a48..aba50291f 100644 --- a/node_modules/tslint/lib/language/utils.js +++ b/node_modules/tslint/lib/language/utils.js @@ -35,6 +35,8 @@ function doesIntersect(failure, disabledIntervals) { exports.doesIntersect = doesIntersect; /** * @returns true if any modifier kinds passed along exist in the given modifiers array + * + * @deprecated use `hasModifier` from `tsutils` */ function hasModifier(modifiers) { var modifierKinds = []; @@ -50,6 +52,8 @@ exports.hasModifier = hasModifier; /** * Determines if the appropriate bit in the parent (VariableDeclarationList) is set, * which indicates this is a "let" or "const". + * + * @deprecated use `isBlockScopedVariableDeclarationList` from `tsutils` */ function isBlockScopedVariable(node) { if (node.kind === ts.SyntaxKind.VariableDeclaration) { @@ -61,12 +65,14 @@ function isBlockScopedVariable(node) { } } exports.isBlockScopedVariable = isBlockScopedVariable; +/** @deprecated use `isBlockScopedVariableDeclarationList` and `getDeclarationOfBindingElement` from `tsutils` */ function isBlockScopedBindingElement(node) { - var variableDeclaration = getBindingElementVariableDeclaration(node); + var variableDeclaration = getBindingElementVariableDeclaration(node); // tslint:disable-line:deprecation // if no variable declaration, it must be a function param, which is block scoped - return (variableDeclaration === null) || isBlockScopedVariable(variableDeclaration); + return (variableDeclaration === null) || isBlockScopedVariable(variableDeclaration); // tslint:disable-line:deprecation } exports.isBlockScopedBindingElement = isBlockScopedBindingElement; +/** @deprecated use `getDeclarationOfBindingElement` from `tsutils` */ function getBindingElementVariableDeclaration(node) { var currentParent = node.parent; while (currentParent.kind !== ts.SyntaxKind.VariableDeclaration) { @@ -83,6 +89,8 @@ exports.getBindingElementVariableDeclaration = getBindingElementVariableDeclarat /** * Finds a child of a given node with a given kind. * Note: This uses `node.getChildren()`, which does extra parsing work to include tokens. + * + * @deprecated use `getChildOfKind` from `tsutils` */ function childOfKind(node, kind) { return node.getChildren().find(function (child) { return child.kind === kind; }); @@ -90,9 +98,11 @@ function childOfKind(node, kind) { exports.childOfKind = childOfKind; /** * @returns true if some ancestor of `node` satisfies `predicate`, including `node` itself. + * + * @deprecated no longer used, use a `while` loop instead */ function someAncestor(node, predicate) { - return predicate(node) || (node.parent !== undefined && someAncestor(node.parent, predicate)); + return predicate(node) || (node.parent !== undefined && someAncestor(node.parent, predicate)); // tslint:disable-line:deprecation } exports.someAncestor = someAncestor; function ancestorWhere(node, predicate) { @@ -106,6 +116,7 @@ function ancestorWhere(node, predicate) { return undefined; } exports.ancestorWhere = ancestorWhere; +/** @deprecated use `isBinaryExpression(node) && isAssignmentKind(node.operatorToken.kind)` with functions from `tsutils` */ function isAssignment(node) { if (node.kind === ts.SyntaxKind.BinaryExpression) { var binaryExpression = node; @@ -119,6 +130,8 @@ function isAssignment(node) { exports.isAssignment = isAssignment; /** * Bitwise check for node flags. + * + * @deprecated use `isNodeFlagSet` from `tsutils` */ function isNodeFlagSet(node, flagToCheck) { // tslint:disable-next-line:no-bitwise @@ -127,6 +140,8 @@ function isNodeFlagSet(node, flagToCheck) { exports.isNodeFlagSet = isNodeFlagSet; /** * Bitwise check for combined node flags. + * + * @deprecated no longer used */ function isCombinedNodeFlagSet(node, flagToCheck) { // tslint:disable-next-line:no-bitwise @@ -135,6 +150,8 @@ function isCombinedNodeFlagSet(node, flagToCheck) { exports.isCombinedNodeFlagSet = isCombinedNodeFlagSet; /** * Bitwise check for combined modifier flags. + * + * @deprecated no longer used */ function isCombinedModifierFlagSet(node, flagToCheck) { // tslint:disable-next-line:no-bitwise @@ -143,6 +160,8 @@ function isCombinedModifierFlagSet(node, flagToCheck) { exports.isCombinedModifierFlagSet = isCombinedModifierFlagSet; /** * Bitwise check for type flags. + * + * @deprecated use `isTypeFlagSet` from `tsutils` */ function isTypeFlagSet(type, flagToCheck) { // tslint:disable-next-line:no-bitwise @@ -151,6 +170,8 @@ function isTypeFlagSet(type, flagToCheck) { exports.isTypeFlagSet = isTypeFlagSet; /** * Bitwise check for symbol flags. + * + * @deprecated use `isSymbolFlagSet` from `tsutils` */ function isSymbolFlagSet(symbol, flagToCheck) { // tslint:disable-next-line:no-bitwise @@ -160,6 +181,8 @@ exports.isSymbolFlagSet = isSymbolFlagSet; /** * Bitwise check for object flags. * Does not work with TypeScript 2.0.x + * + * @deprecated use `isObjectFlagSet` from `tsutils` */ function isObjectFlagSet(objectType, flagToCheck) { // tslint:disable-next-line:no-bitwise @@ -168,6 +191,8 @@ function isObjectFlagSet(objectType, flagToCheck) { exports.isObjectFlagSet = isObjectFlagSet; /** * @returns true if decl is a nested module declaration, i.e. represents a segment of a dotted module path. + * + * @deprecated use `decl.parent!.kind === ts.SyntaxKind.ModuleDeclaration` */ function isNestedModuleDeclaration(decl) { // in a declaration expression like 'module a.b.c' - 'a' is the top level module declaration node and 'b' and 'c' @@ -183,6 +208,7 @@ function unwrapParentheses(node) { return node; } exports.unwrapParentheses = unwrapParentheses; +/** @deprecated use `isFunctionScopeBoundary` from `tsutils` */ function isScopeBoundary(node) { return node.kind === ts.SyntaxKind.FunctionDeclaration || node.kind === ts.SyntaxKind.FunctionExpression @@ -201,10 +227,11 @@ function isScopeBoundary(node) { || node.kind === ts.SyntaxKind.SourceFile && ts.isExternalModule(node); } exports.isScopeBoundary = isScopeBoundary; +/** @deprecated use `isBlockScopeBoundary` from `tsutils` */ function isBlockScopeBoundary(node) { - return isScopeBoundary(node) + return isScopeBoundary(node) // tslint:disable-line:deprecation || node.kind === ts.SyntaxKind.Block - || isLoop(node) + || isLoop(node) // tslint:disable-line:deprecation || node.kind === ts.SyntaxKind.WithStatement || node.kind === ts.SyntaxKind.SwitchStatement || node.parent !== undefined @@ -212,6 +239,7 @@ function isBlockScopeBoundary(node) { || node.parent.kind === ts.SyntaxKind.IfStatement); } exports.isBlockScopeBoundary = isBlockScopeBoundary; +/** @deprecated use `isIterationStatement` from `tsutils` or `typescript` */ function isLoop(node) { return node.kind === ts.SyntaxKind.DoStatement || node.kind === ts.SyntaxKind.WhileStatement @@ -241,6 +269,8 @@ exports.isNumeric = isNumeric; * @param skipTrivia If set to false all trivia preceeding `node` or any of its children is included * @param cb Is called for every token of `node`. It gets the full text of the SourceFile and the position of the token within that text. * @param filter If provided, will be called for every Node and Token found. If it returns false `cb` will not be called for this subtree. + * + * @deprecated use `forEachToken` or `forEachTokenWithTrivia` from `tsutils` */ function forEachToken(node, skipTrivia, cb, filter) { // this function will most likely be called with SourceFile anyways, so there is no need for an additional parameter @@ -305,7 +335,11 @@ function createTriviaHandler(sourceFile, cb) { } return handleTrivia; } -/** Iterate over all comments owned by `node` or its children */ +/** + * Iterate over all comments owned by `node` or its children + * + * @deprecated use `forEachComment` from `tsutils` + */ function forEachComment(node, cb) { /* Visit all tokens and skip trivia. Comment ranges between tokens are parsed without the need of a scanner. diff --git a/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.d.ts b/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.d.ts index 92a61039d..0fd097cc7 100644 --- a/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.d.ts +++ b/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.d.ts @@ -24,7 +24,7 @@ import { ScopeAwareRuleWalker } from "./scopeAwareRuleWalker"; * are a superset of regular scopes (new block scopes are created more frequently in a program). */ export declare abstract class BlockScopeAwareRuleWalker<T, U> extends ScopeAwareRuleWalker<T> { - private blockScopeStack; + private readonly blockScopeStack; constructor(sourceFile: ts.SourceFile, options: IOptions); abstract createBlockScope(node: ts.Node): U; getAllBlockScopes(): U[]; @@ -34,5 +34,5 @@ export declare abstract class BlockScopeAwareRuleWalker<T, U> extends ScopeAware onBlockScopeEnd(): void; findBlockScope(predicate: (scope: U) => boolean): U | undefined; protected visitNode(node: ts.Node): void; - private isBlockScopeBoundary(node); + private isBlockScopeBoundary; } diff --git a/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.js b/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.js index 0b270d2cb..2bfe8865f 100644 --- a/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.js +++ b/node_modules/tslint/lib/language/walker/blockScopeAwareRuleWalker.js @@ -20,6 +20,7 @@ var tslib_1 = require("tslib"); var ts = require("typescript"); var utils_1 = require("../utils"); var scopeAwareRuleWalker_1 = require("./scopeAwareRuleWalker"); +// tslint:disable:deprecation (extends deprecated class and uses deprecated utils - doesn't matter because it's deprecated, too) /** * @deprecated See comment on ScopeAwareRuleWalker. * diff --git a/node_modules/tslint/lib/language/walker/programAwareRuleWalker.d.ts b/node_modules/tslint/lib/language/walker/programAwareRuleWalker.d.ts index d0ae8af52..8f949a03a 100644 --- a/node_modules/tslint/lib/language/walker/programAwareRuleWalker.d.ts +++ b/node_modules/tslint/lib/language/walker/programAwareRuleWalker.d.ts @@ -18,8 +18,8 @@ import * as ts from "typescript"; import { IOptions } from "../rule/rule"; import { RuleWalker } from "./ruleWalker"; export declare class ProgramAwareRuleWalker extends RuleWalker { - private program; - private typeChecker; + private readonly program; + private readonly typeChecker; constructor(sourceFile: ts.SourceFile, options: IOptions, program: ts.Program); getProgram(): ts.Program; getTypeChecker(): ts.TypeChecker; diff --git a/node_modules/tslint/lib/language/walker/ruleWalker.d.ts b/node_modules/tslint/lib/language/walker/ruleWalker.d.ts index f78b4c0ed..9d27e8bcb 100644 --- a/node_modules/tslint/lib/language/walker/ruleWalker.d.ts +++ b/node_modules/tslint/lib/language/walker/ruleWalker.d.ts @@ -19,11 +19,11 @@ import { Fix, IOptions, Replacement, RuleFailure } from "../rule/rule"; import { SyntaxWalker } from "./syntaxWalker"; import { IWalker } from "./walker"; export declare class RuleWalker extends SyntaxWalker implements IWalker { - private sourceFile; - private limit; - private options?; - private failures; - private ruleName; + private readonly sourceFile; + private readonly limit; + private readonly options?; + private readonly failures; + private readonly ruleName; constructor(sourceFile: ts.SourceFile, options: IOptions); getSourceFile(): ts.SourceFile; getLineAndCharacterOfPosition(position: number): ts.LineAndCharacter; diff --git a/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.d.ts b/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.d.ts index 64423e23b..dbb21a9f6 100644 --- a/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.d.ts +++ b/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.d.ts @@ -52,7 +52,7 @@ import { RuleWalker } from "./ruleWalker"; * } */ export declare abstract class ScopeAwareRuleWalker<T> extends RuleWalker { - private scopeStack; + private readonly scopeStack; constructor(sourceFile: ts.SourceFile, options: IOptions); abstract createScope(node: ts.Node): T; getCurrentScope(): T; diff --git a/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.js b/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.js index 2c9cb93a1..15cf26478 100644 --- a/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.js +++ b/node_modules/tslint/lib/language/walker/scopeAwareRuleWalker.js @@ -93,7 +93,7 @@ var ScopeAwareRuleWalker = /** @class */ (function (_super) { } }; ScopeAwareRuleWalker.prototype.isScopeBoundary = function (node) { - return utils_1.isScopeBoundary(node); + return utils_1.isScopeBoundary(node); // tslint:disable-line:deprecation }; return ScopeAwareRuleWalker; }(ruleWalker_1.RuleWalker)); |